> For the complete documentation index, see [llms.txt](https://developer.collibra.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://developer.collibra.com/api/guides/common-concepts/examples.md).

# Examples

## Communities and domains

A community or domain tree, starting from top-level communities:

```graphql
query {
    communities(where: {parent: {_null: true}}) {
        name
        subCommunities {
            name
            subDomains {
                name
            }
        }
        subDomains {
            name
        }
    }
}
```

Domains filtered by the parent community name, including the parent community and responsibilities:

```graphql
query {
    domains(where: {parent: {name: {contains: "Data"}}}) {
        name
        parent {
            name
        }
        responsibilities {
            userGroup {
                name
            }
            user {
                fullName
            }
        }
    }
}
```

Domains that have at least one asset, including the first five assets:

```graphql
query {
    domains(
        where: { assets: {any: {id: {null: false} } } }
    ) {
        name
        assets(limit: 5) {
            fullName
        }
    }
}
```

## Assets

Assets from a particular domain identified by ID, sorted by creation date, including asset tags:

```graphql
query {
    assets(
        where: {domain: {id: {eq: "00000000-0000-0000-0001-000200000001"}}}
        order: {createdOn: desc}
    ) {
        id
        type {
            publicId
        }
        displayName
        fullName
        createdOn
        createdBy {
            fullName
        }
        tags {
            name
        }
    }
}
```

Assets from a particular domain identified by name, having at least one attribute, including all attributes:

```graphql
query {
    assets(where: {
        domain: {name: {eq: "New Data Sets"}}
        attributes: {any: {id: {null: false}}}
    }) {
        fullName
        stringAttributes {
            type {
                publicId
            }
            stringValue
        }
        numericAttributes {
            type {
                publicId
            }
            numericValue
        }
        dateAttributes {
            type {
                publicId
            }
            dateValue
        }
        booleanAttributes {
            type {
                publicId
            }
            booleanValue
        }
    }
}
```

Assets filtered by attribute value, including the parent domain and two specific attributes:

```graphql
query {
    assets( where: { stringAttributes: { typePublicId: "DataType", any: { stringValue: { eq: "Whole Number" } } } } ) {
        fullName
        domain {
            name
        }
        dataType: stringAttributes(where: { type: { publicId: { eq: "DataType" } } } ) {
            stringValue
        }
        description: stringAttributes(where: { type: { publicId: { eq: "Description" } } } ) {
            stringValue
        }
    }
}
```

An asset identified by ID, including all incoming and outgoing relations:

```graphql
query {
    assets (
        where: {id: {eq: "ddd9f9c5-87cf-421f-a406-a52144c693d0"}}
    ) {
        fullName
        outgoingRelations {
            type {
                publicId
            }
            target {
                id
                fullName
            }
        }
        incomingRelations {
            type {
                publicId
            }
            source {
                id
                fullName
            }
        }
    }
}
```

An asset with two different relation types:

```graphql
query {
    assets (
        where: {id: {eq: "ddd9f9c5-87cf-421f-a406-a52144c693d0"}}
    ) {
        fullName
        children: outgoingRelations(
            where: {type: {publicId: {eq: "BusinessAssetGroupsBusinessAsset"}}}
        ) {
            target {
                id
                fullName
            }
        }
        acronyms: outgoingRelations(
            where: {type: {publicId: {eq: "BusinessAssetHasAcronymAcronym"}}}
        ) {
            target {
                id
                fullName
            }
        }
    }
}
```

Assets identified by the related asset ID and the relation type:

```graphql
query {
    assets (
        where: {
            incomingRelations: { any: {
                source: {id: {eq: "ddd9f9c5-87cf-421f-a406-a52144c693d0"}}
                type: { publicId: {eq: "BusinessAssetGroupsBusinessAsset"}}
            }}
        }) {
        fullName
        incomingRelations {
            type { publicId }
        }
    }
}
```

Assets with description attribute:

```graphql
query {
    assets(where: {
        attributes: {
            typePublicId: "Description"
            empty: false
        }
    })
    {
        fullName
        descriptions: stringAttributes(
            where: { type: { publicId: { eq: "Description" } } }
        ) {
            stringValue
        }
    }
}
```

## Schemas, tables, and columns

![schema table column](/files/GDMGJK7fd0pes6NE1KLb)

Top-down query (Schema → Table → Column):

```graphql
query {
    schemas: assets(where: { type: { publicId: {eq: "Schema"}}  }) {
        displayName
        tables: outgoingRelations(where: { type: { publicId: {eq: "SchemaContainsTable"}}  }) {
            target {
                displayName
                columns: incomingRelations(where: { type: { publicId: {eq: "ColumnIsPartOfTable"}}  }) {
                    source {
                        displayName
                    }
                }
            }
        }
    }
}
```

Bottom-up query (Column → Table → Schema):

```graphql
query {
    columns: assets(where: { type: { publicId: {eq: "Column"}}  }) {
        displayName
        tables: outgoingRelations(where: { type: { publicId: {eq: "ColumnIsPartOfTable"}}  }) {
            target {
                displayName
                schemas: incomingRelations(where: { type: { publicId: {eq: "SchemaContainsTable"}}  }) {
                    source {
                        displayName
                    }
                }
            }
        }
    }
}
```

Mixed query (Table → Schema, Table → Column)

```graphql
query {
    tables: assets(where: { type: { publicId: {eq: "Table"}}  }) {
        displayName
        columns: incomingRelations(where: { type: { publicId: {eq: "ColumnIsPartOfTable"}}  }) {
            source {
                displayName
            }
        }
        schemas: incomingRelations(where: { type: { publicId: {eq: "SchemaContainsTable"}}  }) {
            source {
                displayName
            }
        }
    }
}
```

Please note the following tradeoffs for the above queries:

* For the first query it might be difficult to set the limits in the right way as each schema can have a very different number of tables and the same thing happens for table to column relations.
* The second query duplicates each table and schema multiple times thus making it more difficult to read.
* The last query mixes both problems.

Sometimes you need to verify if the tree structure of the response is what you actually need. Consider using a query similar to the following example to specify the limits between all of the entities and still link them using the parent identifier:

```graphql
query {
    schemas: assets(
        where: {
            _and: [
                { type: { publicId: { eq: "Schema" } } }
                { domain: { parent: { name: { eq: "Schemas" } } } }
            ]
        }
    ) {
        id
        fullName
    }
    tables: assets(
        where: {
            _and: [
                { type: { publicId: { eq: "Table" } } }
                { domain: { parent: { name: { eq: "Schemas" } } } }
            ]
        }
    ) {
        fullName
        incomingRelations(where: {type: {publicId: {eq: "SchemaContainsTable"}}}) {
            source {
                id
            }
        }
    }
    columns: assets(
        where: {
            _and: [
                { type: { publicId: { eq: "Column" } } }
                { domain: { parent: { name: { eq: "Schemas" } } } }
            ]
        }
    ) {
        fullName
        outgoingRelations(where: {type: {publicId: {eq: "ColumnIsPartOfTable"}}}) {
            target {
                id
            }
        }
    }
}
```

## Complex relations

Complex relations including all legs:

```graphql
query {
    complexRelations {
        id
        relations {
            type {
                publicId
            }
            target {
                id
                displayName
            }
        }
    }
}
```

All complex relations related to a given asset:

```graphql
query {
    complexRelations(
        where: {
            outgoingRelations: {
                any: { target: { id: { eq: "51f986dc-e19a-4d39-b762-b941c506fafc" } } }
            }
        }
    ) {
        outgoingRelations {
            target {
                id
                fullName
            }
        }
    }
}
```

{% hint style="info" %}
Complex relations are always on the source side of a relation so there is no need to search for this asset in `incomingRelations`.
{% endhint %}


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://developer.collibra.com/api/guides/common-concepts/examples.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.