## Common search fields

URL: https://docs.atlan.com/product/capabilities/build-apps/sdks/python/search/references/searchable-fields/common

> Reference common search fields available on all assets using the Atlan Python SDK (pyatlan) for searching metadata.

# Common search fields

These attributes exist on *all* [assets](https://docs.atlan.com/llms/platform/python/build-your-first-metadata-workflow/llms.txt) in Atlan. You can therefore use them to search *all* assets in Atlan.

:::tip[Look up the asset type you're interested in for a complete list]
The complete list of attributes that can be searched is extensive. Rather than list every single attribute here, particularly since they vary based on the kind of asset you're looking for, instead see the [full model reference](https://docs.atlan.com/llms/platform/types/llms.txt).
:::

## `Asset.GUID` [](/product/capabilities/build-apps/sdks/python/search/references/searchable-fields#keyword "Keyword")

The globally unique identifier (GUID) of any object in Atlan.

The identifier has no meaning, and is randomly generated, but is guaranteed to uniquely identify only a single asset.

### Java

```java showLineNumbers title="Build the query and request"
IndexSearchRequest index = client.assets.select() // (1)
 .where(Asset.GUID.eq("25638e8c-0225-46fd-a70c-304117370c4c")) // (2)
 .toRequest();
```

1. You can search across all assets using the `select()` method of the `assets` member on any client. (For details, see [Searching for assets](https://docs.atlan.com/llms/platform/python/search-assets/llms.txt).)
2. Then provide a predicate and value to search. In this example the `eq()` predicate looks for an exact match, in this case against a specific GUID. This uses a [term query](https://docs.atlan.com/llms/platform/python/term-level/llms.txt) to exactly match the GUID.

 ```java title="Equivalent query from Elastic"
 Query byGuid = TermQuery.of(t -> t
 .field("__guid")
 .value("25638e8c-0225-46fd-a70c-304117370c4c"))
 ._toQuery();
 ```

```java title="Run the search"
Optional asset = index.search(client).stream().findFirst();
if (asset.isPresent())
```

1. For a search by GUID, you would expect either no results, or at most a single result.

### Python

```python showLineNumbers title="Build the query and request"
from pyatlan.client.atlan import AtlanClient
from pyatlan.model.assets import Asset
from pyatlan.model.fluent_search import FluentSearch

index = (FluentSearch() # (1)
 .where(Asset.GUID.eq("25638e8c-0225-46fd-a70c-304117370c4c")) # (2)
 ).to_request()
```

1. You can search across all assets using a `FluentSearch()` object. (For details, see [Searching for assets](https://docs.atlan.com/llms/platform/python/search-assets/llms.txt).)
2. Then provide a predicate and value to search. In this example the `eq()` predicate looks for an exact match, in this case against a specific GUID. This uses a [term query](https://docs.atlan.com/llms/platform/python/term-level/llms.txt) to exactly match the GUID.

```python title="Run the search"
client = AtlanClient()
response = client.asset.search(index)
if response.count > 0:
 guid = response.current_page()[0].guid # (1)
```

1. For a search by GUID, you would expect either no results, or at most a single result.

### Kotlin

```kotlin showLineNumbers title="Build the query and request"
val index = client.assets.select() // (1)
 .where(Asset.GUID.eq("25638e8c-0225-46fd-a70c-304117370c4c")) // (2)
 .toRequest()
```

1. You can search across all assets using the `select()` method of the `assets` member on any client. (For details, see [Searching for assets](https://docs.atlan.com/llms/platform/python/search-assets/llms.txt).)
2. Then provide a predicate and value to search. In this example the `eq()` predicate looks for an exact match, in this case against a specific GUID. This uses a [term query](https://docs.atlan.com/llms/platform/python/term-level/llms.txt) to exactly match the GUID.

 ```kotlin title="Equivalent query from Elastic"
 val byGuid = TermQuery.of(t -> t
 .field("__guid")
 .value("25638e8c-0225-46fd-a70c-304117370c4c"))
 ._toQuery()
 ```

```kotlin title="Run the search"
val asset = index.search(client).stream().findFirst()
if (asset.isPresent)
```

1. For a search by GUID, you would expect either no results, or at most a single result.

### Raw REST API

```json showLineNumbers title="POST /api/meta/search/indexsearch"
{
 "dsl": {
 "query": {
 "term": { "__guid": "25638e8c-0225-46fd-a70c-304117370c4c" } // (1)
 }
 },
 "attributes": [ "__guid" ]
}
```

1. You can use a [term query](https://docs.atlan.com/llms/platform/python/term-level/llms.txt) to exactly match the GUID.

```json showLineNumbers title="Response"
{
 "entities": [
 {
 "attributes": {
 "__guid": "25638e8c-0225-46fd-a70c-304117370c4c"
 },
 "guid": "25638e8c-0225-46fd-a70c-304117370c4c"
 }
 ]
}
```

## `Asset.CREATED_BY` [](/product/capabilities/build-apps/sdks/python/search/references/searchable-fields#keyword "Keyword")

The Atlan user who created this asset.

If created via API, this will be a unique identifier for the API token used. Otherwise, this will be the username of the user that created the asset through the Atlan UI.

### Java

```java showLineNumbers title="Build the query and request"
IndexSearchRequest index = client.assets.select() // (1)
 .where(Asset.CREATED_BY.eq("jdoe")) // (2)
 .includeOnResults(Asset.CREATED_BY) // (3)
 .toRequest();
```

1. You can search across all assets using the `select()` method of the `assets` member on any client. (For details, see [Searching for assets](https://docs.atlan.com/llms/platform/python/search-assets/llms.txt).)
2. Then provide a predicate and value to search. In this example the `eq()` predicate looks for an exact match, in this case against a specific username. This uses a [term query](https://docs.atlan.com/llms/platform/python/term-level/llms.txt) to exactly match the username.

 ```java title="Equivalent query from Elastic"
 Query byCreator = TermQuery.of(t -> t
 .field("__createdBy")
 .value("jdoe"))
 ._toQuery();
 ```

3. To make sure the details of this field are included in each result, add the field to `includeOnResults()`.

```java title="Run the search"
for (Asset result : index.search(client))
```

1. For details, see [Searching for assets](https://docs.atlan.com/llms/platform/python/search-assets/llms.txt).
2. The creator can be retrieved from a result through `.getCreatedBy()`.

### Python

```python showLineNumbers title="Build the query and request"
from pyatlan.client.atlan import AtlanClient
from pyatlan.model.assets import Asset
from pyatlan.model.fluent_search import FluentSearch

index = (FluentSearch() # (1)
 .where(Asset.CREATED_BY.eq("jdoe")) # (2)
 .include_on_results(Asset.CREATED_BY) # (3)
 ).to_request()
```

1. You can search across all assets using a `FluentSearch()` object. (For details, see [Searching for assets](https://docs.atlan.com/llms/platform/python/search-assets/llms.txt).)
2. Then provide a predicate and value to search. In this example the `eq()` predicate looks for an exact match, in this case against a specific username. This uses a [term query](https://docs.atlan.com/llms/platform/python/term-level/llms.txt) to exactly match the username.
3. To make sure the details of this field are included in each result, add the field to `include_on_results()`.

```python title="Run the search"
client = AtlanClient()
for result in client.asset.search(index): # (1)
 creator = result.created_by # (2)
```

1. For details, see [Searching for assets](https://docs.atlan.com/llms/platform/python/search-assets/llms.txt).
2. The creator can be retrieved from a result through `.created_by`.

### Kotlin

```kotlin showLineNumbers title="Build the query and request"
val index = client.assets.select() // (1)
 .where(Asset.CREATED_BY.eq("jdoe")) // (2)
 .includeOnResults(Asset.CREATED_BY) // (3)
 .toRequest()
```

1. You can search across all assets using the `select()` method of the `assets` member on any client. (For details, see [Searching for assets](https://docs.atlan.com/llms/platform/python/search-assets/llms.txt).)
2. Then provide a predicate and value to search. In this example the `eq()` predicate looks for an exact match, in this case against a specific username. This uses a [term query](https://docs.atlan.com/llms/platform/python/term-level/llms.txt) to exactly match the username.

 ```kotlin title="Equivalent query from Elastic"
 val byCreator = TermQuery.of(t -> t
 .field("__createdBy")
 .value("jdoe"))
 ._toQuery()
 ```

3. To make sure the details of this field are included in each result, add the field to `includeOnResults()`.

```kotlin title="Run the search"
for (result in index.search(client))
```

1. For details, see [Searching for assets](https://docs.atlan.com/llms/platform/python/search-assets/llms.txt).
2. The creator can be retrieved from a result through `.createdBy`.

### Raw REST API

```json showLineNumbers title="POST /api/meta/search/indexsearch"
{
 "dsl": {
 "query": {
 "term": { "__createdBy": "jdoe" } // (1)
 }
 },
 "attributes": [ "__createdBy" ]
}
```

1. You can use a [term query](https://docs.atlan.com/llms/platform/python/term-level/llms.txt) to exactly match the username.

```json showLineNumbers title="Response"
{
 "entities": [
 {
 "attributes": {
 "__createdBy": "jdoe"
 },
 "createdBy": "jdoe"
 }
 ]
}
```

## `Asset.UPDATED_BY` [](/product/capabilities/build-apps/sdks/python/search/references/searchable-fields#keyword "Keyword")

The Atlan user who last updated the asset.

If updated via API, this will be a unique identifier for the API token used. Otherwise, this will be the username of the user that made the change through the Atlan UI.

### Java

```java showLineNumbers title="Build the query and request"
IndexSearchRequest index = client.assets.select() // (1)
 .where(Asset.UPDATED_BY.eq("jdoe")) // (2)
 .includeOnResults(Asset.UPDATED_BY) // (3)
 .toRequest();
```

1. You can search across all assets using the `select()` method of the `assets` member on any client. (For details, see [Searching for assets](https://docs.atlan.com/llms/platform/python/search-assets/llms.txt).)
2. Then provide a predicate and value to search. In this example the `eq()` predicate looks for an exact match, in this case against a specific username. This uses a [term query](https://docs.atlan.com/llms/platform/python/term-level/llms.txt) to exactly match the username.

 ```java title="Equivalent query from Elastic"
 Query byUpdater = TermQuery.of(t -> t
 .field("__modifiedBy")
 .value("jdoe"))
 ._toQuery();
 ```

3. To make sure the details of this field are included in each result, add the field to `includeOnResults()`.

```java title="Run the search"
for (Asset result : index.search(client))
```

1. For details, see [Searching for assets](https://docs.atlan.com/llms/platform/python/search-assets/llms.txt).
2. The updater can be retrieved from a result through `.getUpdatedBy()`.

### Python

```python showLineNumbers title="Build the query and request"
from pyatlan.client.atlan import AtlanClient
from pyatlan.model.assets import Asset
from pyatlan.model.fluent_search import FluentSearch

index = (FluentSearch() # (1)
 .where(Asset.UPDATED_BY.eq("jdoe")) # (2)
 .include_on_results(Asset.UPDATED_BY) # (3)
 ).to_request()
```

1. You can search across all assets using a `FluentSearch()` object. (For details, see [Searching for assets](https://docs.atlan.com/llms/platform/python/search-assets/llms.txt).)
2. Then provide a predicate and value to search. In this example the `eq()` predicate looks for an exact match, in this case against a specific username. This uses a [term query](https://docs.atlan.com/llms/platform/python/term-level/llms.txt) to exactly match the username.
3. To make sure the details of this field are included in each result, add the field to `include_on_results()`.

```python title="Run the search"
client = AtlanClient()
for result in client.asset.search(index): # (1)
 updater = result.updated_by # (2)
```

1. For details, see [Searching for assets](https://docs.atlan.com/llms/platform/python/search-assets/llms.txt).
2. The updater can be retrieved from a result through `.updated_by`.

### Kotlin

```kotlin showLineNumbers title="Build the query and request"
val index = client.assets.select() // (1)
 .where(Asset.UPDATED_BY.eq("jdoe")) // (2)
 .includeOnResults(Asset.UPDATED_BY) // (3)
 .toRequest()
```

1. You can search across all assets using the `select()` method of the `assets` member on any client. (For details, see [Searching for assets](https://docs.atlan.com/llms/platform/python/search-assets/llms.txt).)
2. Then provide a predicate and value to search. In this example the `eq()` predicate looks for an exact match, in this case against a specific username. This uses a [term query](https://docs.atlan.com/llms/platform/python/term-level/llms.txt) to exactly match the username.

 ```kotlin title="Equivalent query from Elastic"
 val byUpdater = TermQuery.of(t -> t
 .field("__modifiedBy")
 .value("jdoe"))
 ._toQuery()
 ```

3. To make sure the details of this field are included in each result, add the field to `includeOnResults()`.

```kotlin title="Run the search"
for (result in index.search(client))
```

1. For details, see [Searching for assets](https://docs.atlan.com/llms/platform/python/search-assets/llms.txt).
2. The updater can be retrieved from a result through `.updatedBy`.

### Raw REST API

```json showLineNumbers title="POST /api/meta/search/indexsearch"
{
 "dsl": {
 "query": {
 "term": { "__modifiedBy": "jdoe" } // (1)
 }
 },
 "attributes": [ "__modifiedBy" ]
}
```

1. You can use a [term query](https://docs.atlan.com/llms/platform/python/term-level/llms.txt) to exactly match the username.

```json showLineNumbers title="Response"
{
 "entities": [
 {
 "attributes": {
 "__modifiedBy": "jdoe"
 },
 "updatedBy": "jdoe"
 }
 ]
}
```

## `Asset.CREATE_TIME` [](/product/capabilities/build-apps/sdks/python/search/references/searchable-fields#date "Date")

The time (in milliseconds) when the asset was created.

This is stored as an epoch: the milliseconds since January 1, 1970 (UTC).

### Java

```java showLineNumbers title="Build the query and request"
IndexSearchRequest index = client.assets.select() // (1)
 .where(Asset.CREATE_TIME.gte(1640995200000L)) // (2)
 .includeOnResults(Asset.CREATE_TIME) // (3)
 .toRequest();
```

1. You can search across all assets using the `select()` method of the `assets` member on any client. (For details, see [Searching for assets](https://docs.atlan.com/llms/platform/python/search-assets/llms.txt).)
2. Then provide a predicate and value to search. In this example the `gte()` predicate looks for any values greater than or equal to the provided epoch-style date (milliseconds since January 1, 1970). This uses a [range query](https://docs.atlan.com/llms/platform/python/term-level/llms.txt) to find any assets created on or after a particular date.

 ```java title="Equivalent query from Elastic"
 Query byCreation = RangeQuery.of(r -> r
 .field("__timestamp")
 .gte(JsonData.of(1640995200000L)))
 ._toQuery();
 ```

3. To make sure the details of this field are included in each result, add the field to `includeOnResults()`.

```java title="Run the search"
for (Asset result : index.search(client))
```

1. For details, see [Searching for assets](https://docs.atlan.com/llms/platform/python/search-assets/llms.txt).
2. The creation time can be retrieved from a result through `.getCreateTime()`.

### Python

```python showLineNumbers title="Build the query and request"
from pyatlan.client.atlan import AtlanClient
from pyatlan.model.assets import Asset
from pyatlan.model.fluent_search import FluentSearch

index = (FluentSearch() # (1)
 .where(Asset.CREATE_TIME.gte(1640995200000)) # (2)
 .include_on_results(Asset.CREATE_TIME) # (3)
 ).to_request()
```

1. You can search across all assets using a `FluentSearch()` object. (For details, see [Searching for assets](https://docs.atlan.com/llms/platform/python/search-assets/llms.txt).)
2. Then provide a predicate and value to search. In this example the `gte()` predicate looks for any values greater than or equal to the provided epoch-style date (milliseconds since January 1, 1970). This uses a [range query](https://docs.atlan.com/llms/platform/python/term-level/llms.txt) to find any assets created on or after a particular date.
3. To make sure the details of this field are included in each result, add the field to `include_on_results()`.

```python title="Run the search"
client = AtlanClient()
for result in client.asset.search(index): # (1)
 created = result.create_time # (2)
```

1. For details, see [Searching for assets](https://docs.atlan.com/llms/platform/python/search-assets/llms.txt).
2. The creation time can be retrieved from a result through `.create_time`.

### Kotlin

```kotlin showLineNumbers title="Build the query and request"
val index = client.assets.select() // (1)
 .where(Asset.CREATE_TIME.gte(1640995200000L)) // (2)
 .includeOnResults(Asset.CREATE_TIME) // (3)
 .toRequest()
```

1. You can search across all assets using the `select()` method of the `assets` member on any client. (For details, see [Searching for assets](https://docs.atlan.com/llms/platform/python/search-assets/llms.txt).)
2. Then provide a predicate and value to search. In this example the `gte()` predicate looks for any values greater than or equal to the provided epoch-style date (milliseconds since January 1, 1970). This uses a [range query](https://docs.atlan.com/llms/platform/python/term-level/llms.txt) to find any assets created on or after a particular date.

 ```kotlin title="Equivalent query from Elastic"
 val byCreation = RangeQuery.of(r -> r
 .field("__timestamp")
 .gte(JsonData.of(1640995200000L)))
 ._toQuery()
 ```

3. To make sure the details of this field are included in each result, add the field to `includeOnResults()`.

```kotlin title="Run the search"
for (result in index.search(client))
```

1. For details, see [Searching for assets](https://docs.atlan.com/llms/platform/python/search-assets/llms.txt).
2. The creation time can be retrieved from a result through `.createTime`.

### Raw REST API

```json showLineNumbers title="POST /api/meta/search/indexsearch"
{
 "dsl": {
 "query": {
 "range": { "__timestamp": { "gte": 1640995200000 }} // (1)
 }
 },
 "attributes": [ "__timestamp" ]
}
```

1. You can use a [range query](https://docs.atlan.com/llms/platform/python/term-level/llms.txt) to find any assets created on or after a particular date.

```json showLineNumbers title="Response"
{
 "entities": [
 {
 "attributes": {
 "__timestamp": 1654992094524
 },
 "createTime": 1654992094524
 }
 ]
}
```

## `Asset.UPDATE_TIME` [](/product/capabilities/build-apps/sdks/python/search/references/searchable-fields#date "Date")

The time (in milliseconds) when the asset was last updated.

This is stored as an epoch: the milliseconds since January 1, 1970 (UTC).

### Java

```java showLineNumbers title="Build the query and request"
IndexSearchRequest index = client.assets.select() // (1)
 .where(Asset.UPDATE_TIME.gte(1640995200000L)) // (2)
 .includeOnResults(Asset.UPDATE_TIME) // (3)
 .toRequest();
```

1. You can search across all assets using the `select()` method of the `assets` member on any client. (For details, see [Searching for assets](https://docs.atlan.com/llms/platform/python/search-assets/llms.txt).)
2. Then provide a predicate and value to search. In this example the `gte()` predicate looks for any values greater than or equal to the provided epoch-style date (milliseconds since January 1, 1970). This uses a [range query](https://docs.atlan.com/llms/platform/python/term-level/llms.txt) to find any assets modified on or after a particular date.

 ```java title="Equivalent query from Elastic"
 Query byUpdate = RangeQuery.of(r -> r
 .field("__modificationTimestamp")
 .gte(JsonData.of(1640995200000L)))
 ._toQuery();
 ```

3. To make sure the details of this field are included in each result, add the field to `includeOnResults()`.

```java title="Run the search"
for (Asset result : index.search(client))
```

1. For details, see [Searching for assets](https://docs.atlan.com/llms/platform/python/search-assets/llms.txt).
2. The last modified time can be retrieved from a result through `.getUpdateTime()`.

### Python

```python showLineNumbers title="Build the query and request"
from pyatlan.client.atlan import AtlanClient
from pyatlan.model.assets import Asset
from pyatlan.model.fluent_search import FluentSearch

index = (FluentSearch() # (1)
 .where(Asset.UPDATE_TIME.gte(1640995200000)) # (2)
 .include_on_results(Asset.UPDATE_TIME) # (3)
 ).to_request()
```

1. You can search across all assets using a `FluentSearch()` object. (For details, see [Searching for assets](https://docs.atlan.com/llms/platform/python/search-assets/llms.txt).)
2. Then provide a predicate and value to search. In this example the `gte()` predicate looks for any values greater than or equal to the provided epoch-style date (milliseconds since January 1, 1970). This uses a [range query](https://docs.atlan.com/llms/platform/python/term-level/llms.txt) to find any assets modified on or after a particular date.
3. To make sure the details of this field are included in each result, add the field to `include_on_results()`.

```python title="Run the search"
client = AtlanClient()
for result in client.asset.search(index): # (1)
 updated = result.update_time # (2)
```

1. For details, see [Searching for assets](https://docs.atlan.com/llms/platform/python/search-assets/llms.txt).
2. The last modified time can be retrieved from a result through `.update_time`.

### Kotlin

```kotlin showLineNumbers title="Build the query and request"
val index = client.assets.select() // (1)
 .where(Asset.UPDATE_TIME.gte(1640995200000L)) // (2)
 .includeOnResults(Asset.UPDATE_TIME) // (3)
 .toRequest()
```

1. You can search across all assets using the `select()` method of the `assets` member on any client. (For details, see [Searching for assets](https://docs.atlan.com/llms/platform/python/search-assets/llms.txt).)
2. Then provide a predicate and value to search. In this example the `gte()` predicate looks for any values greater than or equal to the provided epoch-style date (milliseconds since January 1, 1970). This uses a [range query](https://docs.atlan.com/llms/platform/python/term-level/llms.txt) to find any assets modified on or after a particular date.

 ```kotlin title="Equivalent query from Elastic"
 val byUpdate = RangeQuery.of(r -> r
 .field("__modificationTimestamp")
 .gte(JsonData.of(1640995200000L)))
 ._toQuery()
 ```

3. To make sure the details of this field are included in each result, add the field to `includeOnResults()`.

```kotlin title="Run the search"
for (result in index.search(client))
```

1. For details, see [Searching for assets](https://docs.atlan.com/llms/platform/python/search-assets/llms.txt).
2. The last modified time can be retrieved from a result through `.updateTime`.

### Raw REST API

```json showLineNumbers title="POST /api/meta/search/indexsearch"
{
 "dsl": {
 "query": {
 "range": { "__modificationTimestamp": { "gte": 1640995200000 }} // (1)
 }
 },
 "attributes": [ "__modificationTimestamp" ]
}
```

1. You can use a [range query](https://docs.atlan.com/llms/platform/python/term-level/llms.txt) to find any assets modified on or after a particular date.

```json showLineNumbers title="Response"
{
 "entities": [
 {
 "attributes": {
 "__modificationTimestamp": 1654905667786
 },
 "updateTime": 1654905667786
 }
 ]
}
```

## `Asset.STATUS` [](/product/capabilities/build-apps/sdks/python/search/references/searchable-fields#keyword "Keyword") {#assetstatus}

The asset status in Atlan. The expected values are:

- `ACTIVE` for assets that are available in Atlan.
- `DELETED` for assets that are (soft-)deleted in Atlan. These won't appear in the UI or API responses unless explicitly requested.

:::warning[Only visible for soft-deleted (archived) assets]
Hard-deleted, or "purged" assets are fully erased, and therefore no status exists for them.
:::

### Java

```java showLineNumbers title="Build the query and request"
IndexSearchRequest index = client.assets.select() // (1)
 .where(Asset.STATUS.eq(AtlanStatus.DELETED)) // (2)
 .includeOnResults(Asset.STATUS) // (3)
 .toRequest();
```

1. You can search across all assets using the `select()` method of the `assets` member on any client. (For details, see [Searching for assets](https://docs.atlan.com/llms/platform/python/search-assets/llms.txt).)
2. Then provide a predicate and value to search. In this example the `eq()` predicate looks for an exact match, in this case against a specific state. This uses a [term query](https://docs.atlan.com/llms/platform/python/term-level/llms.txt) to exactly match the state.

 ```java title="Equivalent query from Elastic"
 Query byState = TermQuery.of(t -> t
 .field("__state")
 .value(AtlanStatus.DELETED.getValue()))
 ._toQuery();
 ```

3. To make sure the details of this field are included in each result, add the field to `includeOnResults()`.

```java title="Run the search"
for (Asset result : index.search(client))
```

1. For details, see [Searching for assets](https://docs.atlan.com/llms/platform/python/search-assets/llms.txt).
2. The status can be retrieved from a result through `.getStatus()`.

### Python

```python showLineNumbers title="Build the query and request"
from pyatlan.client.atlan import AtlanClient
from pyatlan.model.assets import Asset
from pyatlan.model.fluent_search import FluentSearch

index = (FluentSearch() # (1)
 .where(Asset.STATUS.eq(EntityStatus.DELETED.value)) # (2)
 .include_on_results(Asset.STATUS) # (3)
 ).to_request()
```

1. You can search across all assets using a `FluentSearch()` object. (For details, see [Searching for assets](https://docs.atlan.com/llms/platform/python/search-assets/llms.txt).)
2. Then provide a predicate and value to search. In this example the `eq()` predicate looks for an exact match, in this case against a specific state. This uses a [term query](https://docs.atlan.com/llms/platform/python/term-level/llms.txt) to exactly match the state.
3. To make sure the details of this field are included in each result, add the field to `include_on_results()`.

```python title="Run the search"
client = AtlanClient()
for result in client.asset.search(index): # (1)
 status = result.status # (2)
```

1. For details, see [Searching for assets](https://docs.atlan.com/llms/platform/python/search-assets/llms.txt).
2. The status can be retrieved from a result through `.status`.

### Kotlin

```kotlin showLineNumbers title="Build the query and request"
val index = client.assets.select() // (1)
 .where(Asset.STATUS.eq(AtlanStatus.DELETED)) // (2)
 .includeOnResults(Asset.STATUS) // (3)
 .toRequest()
```

1. You can search across all assets using the `select()` method of the `assets` member on any client. (For details, see [Searching for assets](https://docs.atlan.com/llms/platform/python/search-assets/llms.txt).)
2. Then provide a predicate and value to search. In this example the `eq()` predicate looks for an exact match, in this case against a specific state. This uses a [term query](https://docs.atlan.com/llms/platform/python/term-level/llms.txt) to exactly match the state.

 ```kotlin title="Equivalent query from Elastic"
 val byState = TermQuery.of(t -> t
 .field("__state")
 .value(AtlanStatus.DELETED.getValue()))
 ._toQuery()
 ```

3. To make sure the details of this field are included in each result, add the field to `includeOnResults()`.

```kotlin title="Run the search"
for (result in index.search(client))
```

1. For details, see [Searching for assets](https://docs.atlan.com/llms/platform/python/search-assets/llms.txt).
2. The status can be retrieved from a result through `.status`.

### Raw REST API

```json showLineNumbers title="POST /api/meta/search/indexsearch"
{
 "dsl": {
 "query": {
 "term": { "__state": "DELETED" } // (1)
 }
 },
 "attributes": [ "__state" ]
}
```

1. You can use a [term query](https://docs.atlan.com/llms/platform/python/term-level/llms.txt) to exactly match the state.

```json showLineNumbers title="Response"
{
 "entities": [
 {
 "attributes": {
 "__state": "DELETED"
 },
 "status": "DELETED"
 }
 ]
}
```

## `Asset.ATLAN_TAGS` [](/product/capabilities/build-apps/sdks/python/search/references/searchable-fields#keyword "Keyword")

All directly-assigned Atlan tags that exist on an asset.

:::warning[Internal representation]
The Atlan tag names in the index are an Atlan-internal hashed string, *not* the human-readable name you see in the UI. The value you search for must be this Atlan-internal hashed string.
:::

### Java

```java showLineNumbers title="Build the query and request"
IndexSearchRequest index = client.assets.select() // (1)
 .where(Asset.ATLAN_TAGS.hasAnyValue()) // (2)
 .toRequest();
```

1. You can search across all assets using the `select()` method of the `assets` member on any client. (For details, see [Searching for assets](https://docs.atlan.com/llms/platform/python/search-assets/llms.txt).)
2. Then provide a predicate and value to search. In this example the `hasAnyValue()` predicate looks for any value in this field, in this case any Atlan tags. This uses an [exists query](https://docs.atlan.com/llms/platform/python/term-level/llms.txt) to check that any value exists in the field.

 ```java title="Equivalent query from Elastic"
 Query byAtlanTag = ExistsQuery.of(q -> q
 .field("__traitNames"))
 ._toQuery();
 ```

```java title="Run the search"
for (Asset result : index.search(client))
```

1. For details, see [Searching for assets](https://docs.atlan.com/llms/platform/python/search-assets/llms.txt).
2. The assigned Atlan tags can be retrieved from a result through `.getAtlanTags()`. Note that the Java SDK will automatically translate these from the internal hashed string representation of Atlan into the Atlan tag names as you would recognize them in the UI.

### Python

```python showLineNumbers title="Build the query and request"
from pyatlan.client.atlan import AtlanClient
from pyatlan.model.assets import Asset
from pyatlan.model.fluent_search import FluentSearch

index = (FluentSearch() # (1)
 .where(Asset.ATLAN_TAGS.has_any_value()) # (2)
 ).to_request()
```

1. You can search across all assets using a `FluentSearch()` object. (For details, see [Searching for assets](https://docs.atlan.com/llms/platform/python/search-assets/llms.txt).)
2. Then provide a predicate and value to search. In this example the `has_any_value()` predicate looks for any value in this field, in this case any Atlan tags. This uses an [exists query](https://docs.atlan.com/llms/platform/python/term-level/llms.txt) to check that any value exists in the field.

```python title="Run the search"
client = AtlanClient()
for result in client.asset.search(index): # (1)
 atlan_tags = result.atlan_tags # (2)
```

1. For details, see [Searching for assets](https://docs.atlan.com/llms/platform/python/search-assets/llms.txt).
2. The assigned Atlan tags can be retrieved from a result through `.atlan_tags`. Note that the Python SDK will automatically translate these from the internal hashed string representation of Atlan into the Atlan tag names as you would recognize them in the UI.

### Kotlin

```kotlin showLineNumbers title="Build the query and request"
val index = client.assets.select() // (1)
 .where(Asset.ATLAN_TAGS.hasAnyValue()) // (2)
 .toRequest()
```

1. You can search across all assets using the `select()` method of the `assets` member on any client. (For details, see [Searching for assets](https://docs.atlan.com/llms/platform/python/search-assets/llms.txt).)
2. Then provide a predicate and value to search. In this example the `hasAnyValue()` predicate looks for any value in this field, in this case any Atlan tags. This uses an [exists query](https://docs.atlan.com/llms/platform/python/term-level/llms.txt) to check that any value exists in the field.

 ```kotlin title="Equivalent query from Elastic"
 val byAtlanTag = ExistsQuery.of(q -> q
 .field("__traitNames"))
 ._toQuery()
 ```

```java title="Run the search"
for (result in index.search(client))
```

1. For details, see [Searching for assets](https://docs.atlan.com/llms/platform/python/search-assets/llms.txt).
2. The assigned Atlan tags can be retrieved from a result through `.atlanTags`. Note that the Java SDK will automatically translate these from the internal hashed string representation of Atlan into the Atlan tag names as you would recognize them in the UI.

### Raw REST API

```json showLineNumbers title="POST /api/meta/search/indexsearch"
{
 "dsl": {
 "query": {
 "exists": { "field": "__traitNames" } // (1)
 }
 },
 "attributes": [ "__classificationNames" ]
}
```

1. You can use an [exists query](https://docs.atlan.com/llms/platform/python/term-level/llms.txt) to find assets that have a directly-assigned Atlan tag.

```json showLineNumbers title="Response"
{
 "entities": [
 {
 "attributes": {
 "__classificationNames": "|E4FUqA9JFgb0VHRZWRAq95|I0oabU4LhZ69Nb0FKBGKfS|"
 },
 "classificationNames": [
 "I0oabU4LhZ69Nb0FKBGKfS",
 "E4FUqA9JFgb0VHRZWRAq95"
 ]
 }
 ]
}
```

> *Details — see full content on the documentation site.*

## `Asset.PROPAGATED_ATLAN_TAGS` [](/product/capabilities/build-apps/sdks/python/search/references/searchable-fields#keyword "Keyword")

All propagated Atlan tags that exist on an asset. This includes Atlan tags propagated by:

- Upstream assets in lineage (from source to target)
- Parent assets (for example, from tables to columns)
- Linked terms

:::warning[Internal representation]
The Atlan tag names in the index are an Atlan-internal hashed string, *not* the human-readable name you see in the UI. The value you search for must be this Atlan-internal hashed string.
:::

### Java

```java showLineNumbers title="Build the query and request"
IndexSearchRequest index = client.assets.select() // (1)
 .where(Asset.PROPAGATED_ATLAN_TAGS.hasAnyValue()) // (2)
 .toRequest();
```

1. You can search across all assets using the `select()` method of the `assets` member on any client. (For details, see [Searching for assets](https://docs.atlan.com/llms/platform/python/search-assets/llms.txt).)
2. Then provide a predicate and value to search. In this example the `hasAnyValue()` predicate looks for any value in this field, in this case any propagated Atlan tags. This uses an [exists query](https://docs.atlan.com/llms/platform/python/term-level/llms.txt) to check that any value exists in the field.

 ```java title="Equivalent query from Elastic"
 Query byAtlanTag = ExistsQuery.of(q -> q
 .field("__propagatedTraitNames"))
 ._toQuery();
 ```

```java title="Run the search"
for (Asset result : index.search(client))
```

1. For details, see [Searching for assets](https://docs.atlan.com/llms/platform/python/search-assets/llms.txt).
2. The assigned Atlan tags can be retrieved from a result through `.getAtlanTags()`. Note that the Java SDK will automatically translate these from the internal hashed string representation of Atlan into the Atlan tag names as you would recognize them in the UI.

 :::note[How do I distinguish between propagated and direct tags?]
From each `AtlanTag` object you can use `.getEntityGuid()`.

- If this matches the GUID of the asset, the tag has been directly assigned to the asset
- If this is a different GUID from the asset, the tag has been propagated to the asset (the GUID indicates the asset the tag was propagated from)
 :::

### Python

```python showLineNumbers title="Build the query and request"
from pyatlan.client.atlan import AtlanClient
from pyatlan.model.assets import Asset
from pyatlan.model.fluent_search import FluentSearch

index = (FluentSearch() # (1)
 .where(Asset.PROPAGATED_ATLAN_TAGS.has_any_value()) # (2)
 ).to_request()
```

1. You can search across all assets using a `FluentSearch()` object. (For details, see [Searching for assets](https://docs.atlan.com/llms/platform/python/search-assets/llms.txt).)
2. Then provide a predicate and value to search. In this example the `has_any_value()` predicate looks for any value in this field, in this case any propagated Atlan tags. This uses an [exists query](https://docs.atlan.com/llms/platform/python/term-level/llms.txt) to check that any value exists in the field.

```python title="Run the search"
client = AtlanClient()
for result in client.asset.search(index): # (1)
 atlan_tags = result.atlan_tags # (2)
```

1. For details, see [Searching for assets](https://docs.atlan.com/llms/platform/python/search-assets/llms.txt).
2. The assigned Atlan tags can be retrieved from a result through `.atlan_tags`. Note that the Python SDK will automatically translate these from the internal hashed string representation of Atlan into the Atlan tag names as you would recognize them in the UI.

 :::note[How do I distinguish between propagated and direct tags?]
From each `AtlanTag` object you can use `.entity_guid`.

- If this matches the GUID of the asset, the tag has been directly assigned to the asset
- If this is a different GUID from the asset, the tag has been propagated to the asset (the GUID indicates the asset the tag was propagated from)
 :::

### Kotlin

```kotlin showLineNumbers title="Build the query and request"
val index = client.assets.select() // (1)
 .where(Asset.PROPAGATED_ATLAN_TAGS.hasAnyValue()) // (2)
 .toRequest()
```

1. You can search across all assets using the `select()` method of the `assets` member on any client. (For details, see [Searching for assets](https://docs.atlan.com/llms/platform/python/search-assets/llms.txt).)
2. Then provide a predicate and value to search. In this example the `hasAnyValue()` predicate looks for any value in this field, in this case any propagated Atlan tags. This uses an [exists query](https://docs.atlan.com/llms/platform/python/term-level/llms.txt) to check that any value exists in the field.

 ```kotlin title="Equivalent query from Elastic"
 val byAtlanTag = ExistsQuery.of(q -> q
 .field("__propagatedTraitNames"))
 ._toQuery()
 ```

```kotlin title="Run the search"
for (result in index.search(client))
```

1. For details, see [Searching for assets](https://docs.atlan.com/llms/platform/python/search-assets/llms.txt).
2. The assigned Atlan tags can be retrieved from a result through `.atlanTags`. Note that the Java SDK will automatically translate these from the internal hashed string representation of Atlan into the Atlan tag names as you would recognize them in the UI.

 :::note[How do I distinguish between propagated and direct tags?]
From each `AtlanTag` object you can use `.entityGuid`.

- If this matches the GUID of the asset, the tag has been directly assigned to the asset
- If this is a different GUID from the asset, the tag has been propagated to the asset (the GUID indicates the asset the tag was propagated from)
 :::

### Raw REST API

```json showLineNumbers title="POST /api/meta/search/indexsearch"
{
 "dsl": {
 "query": {
 "exists": { "field": "__propagatedTraitNames" } // (1)
 }
 },
 "attributes": [ "__propagatedClassificationNames" ]
}
```

1. You can use an [exists query](https://docs.atlan.com/llms/platform/python/term-level/llms.txt) to find assets that have a propagated Atlan tag.

```json showLineNumbers title="Response"
{
 "entities": [
 {
 "attributes": {
 "__propagatedClassificationNames": "|E4FUqA9JFgb0VHRZWRAq95|I0oabU4LhZ69Nb0FKBGKfS|"
 },
 "classificationNames": [
 "I0oabU4LhZ69Nb0FKBGKfS",
 "E4FUqA9JFgb0VHRZWRAq95"
 ]
 }
 ]
}
```

> *Details — see full content on the documentation site.*

## `Asset.ASSIGNED_TERMS` [](/product/capabilities/build-apps/sdks/python/search/references/searchable-fields#keyword "Keyword") [](/product/capabilities/build-apps/sdks/python/search/references/searchable-fields#text "Text")

All terms attached to an asset.

### Java

```java showLineNumbers title="Build the query and request"
IndexSearchRequest index = client.assets.select() // (1)
 .where(Asset.ASSIGNED_TERMS.hasAnyValue()) // (2)
 .includeOnResults(Asset.ASSIGNED_TERMS) // (3)
 .toRequest();
```

1. You can search across all assets using the `select()` method of the `assets` member on any client. (For details, see [Searching for assets](https://docs.atlan.com/llms/platform/python/search-assets/llms.txt).)
2. Then provide a predicate and value to search. In this example the `hasAnyValue()` predicate looks for any value in this field, in this case any term assignments. This uses an [exists query](https://docs.atlan.com/llms/platform/python/term-level/llms.txt) to check that any value exists in the field.

 ```java title="Equivalent query from Elastic"
 Query byMeaning = ExistsQuery.of(q -> q
 .field("__meanings"))
 ._toQuery();
 ```

3. To make sure the details of this field are included in each result, add the field to `includeOnResults()`.

```java title="Run the search"
for (Asset result : index.search(client))
```

1. For details, see [Searching for assets](https://docs.atlan.com/llms/platform/python/search-assets/llms.txt).
2. The assigned Atlan tags can be retrieved from a result through `.getAssignedTerms()`.

### Python

```python showLineNumbers title="Build the query and request"
from pyatlan.client.atlan import AtlanClient
from pyatlan.model.assets import Asset
from pyatlan.model.fluent_search import FluentSearch

index = (FluentSearch() # (1)
 .where(Asset.ASSIGNED_TERMS.has_any_value()) # (2)
 .include_on_results(Asset.ASSIGNED_TERMS) # (3)
 ).to_request()
```

1. You can search across all assets using a `FluentSearch()` object. (For details, see [Searching for assets](https://docs.atlan.com/llms/platform/python/search-assets/llms.txt).)
2. Then provide a predicate and value to search. In this example the `hasAnyValue()` predicate looks for any value in this field, in this case any term assignments. This uses an [exists query](https://docs.atlan.com/llms/platform/python/term-level/llms.txt) to check that any value exists in the field.
3. To make sure the details of this field are included in each result, add the field to `include_on_results()`.

```python title="Run the search"
client = AtlanClient()
for result in client.asset.search(index): # (1)
 assigned_terms = result.assigned_terms # (2)
```

1. For details, see [Searching for assets](https://docs.atlan.com/llms/platform/python/search-assets/llms.txt).
2. The assigned Atlan tags can be retrieved from a result through `.assigned_terms`.

### Kotlin

```kotlin showLineNumbers title="Build the query and request"
val index = client.assets.select() // (1)
 .where(Asset.ASSIGNED_TERMS.hasAnyValue()) // (2)
 .includeOnResults(Asset.ASSIGNED_TERMS) // (3)
 .toRequest()
```

1. You can search across all assets using the `select()` method of the `assets` member on any client. (For details, see [Searching for assets](https://docs.atlan.com/llms/platform/python/search-assets/llms.txt).)
2. Then provide a predicate and value to search. In this example the `hasAnyValue()` predicate looks for any value in this field, in this case any term assignments. This uses an [exists query](https://docs.atlan.com/llms/platform/python/term-level/llms.txt) to check that any value exists in the field.

 ```kotlin title="Equivalent query from Elastic"
 val byMeaning = ExistsQuery.of(q -> q
 .field("__meanings"))
 ._toQuery()
 ```

3. To make sure the details of this field are included in each result, add the field to `includeOnResults()`.

```kotlin title="Run the search"
for (result in index.search(client))
```

1. For details, see [Searching for assets](https://docs.atlan.com/llms/platform/python/search-assets/llms.txt).
2. The assigned Atlan tags can be retrieved from a result through `.assignedTerms`.

### Raw REST API

```json showLineNumbers title="POST /api/meta/search/indexsearch"
{
 "dsl": {
 "query": {
 "exists": { "field": "__meanings" } // (1)
 }
 },
 "attributes": [ "__meanings" ]
}
```

1. You can use an [exists query](https://docs.atlan.com/llms/platform/python/term-level/llms.txt) to find assets that have any terms assigned.

```json showLineNumbers title="Response"
{
 "entities": [
 {
 "meanings": [
 {
 "termGuid": "b4113341-251b-4adc-81fb-2420501c30e6",
 "relationGuid": "10df06a1-5b7c-492f-b827-bf4f46931c3e",
 "displayText": "Example Term",
 "confidence": 0
 }
 ]
 }
 ]
}
```

> *Details — see full content on the documentation site.*

## `Asset.TYPE_NAME` [](/product/capabilities/build-apps/sdks/python/search/references/searchable-fields#keyword "Keyword") [](/product/capabilities/build-apps/sdks/python/search/references/searchable-fields#text "Text") {#assettype_name}

The type of asset. For example, `Table`, `Column`, and so on.

### Java

```java showLineNumbers title="Build the query and request"
IndexSearchRequest index = client.assets.select() // (1)
 .where(Asset.TYPE_NAME.eq(GlossaryTerm.TYPE_NAME)) // (2)
 .toRequest();
```

1. You can search across all assets using the `select()` method of the `assets` member on any client. (For details, see [Searching for assets](https://docs.atlan.com/llms/platform/python/search-assets/llms.txt).)
2. Then provide a predicate and value to search. The Java SDK provides `Asset.TYPE_NAME.eq()` and `Asset.TYPE_NAME.in()` to restrict assets to one or more specific types.

 ```java title="Equivalent query from Elastic"
 Query byType = TermQuery.of(t -> t
 .field("__typeName.keyword")
 .value(GlossaryTerm.TYPE_NAME))
 ._toQuery();
 ```

```java title="Run the search"
for (Asset result : index.search(client))
```

1. For details, see [Searching for assets](https://docs.atlan.com/llms/platform/python/search-assets/llms.txt).
2. The type name can be retrieved from a result through `.getTypeName()`.

### Python

```python showLineNumbers title="Build the query and request"
from pyatlan.client.atlan import AtlanClient
from pyatlan.model.assets import Asset, AtlasGlossaryTerm
from pyatlan.model.fluent_search import CompoundQuery, FluentSearch

index = (FluentSearch() # (1)
 .where(CompoundQuery.asset_type(AtlasGlossaryTerm)) # (2)
 ).to_request()
```

1. You can search across all assets using a `FluentSearch()` object. (For details, see [Searching for assets](https://docs.atlan.com/llms/platform/python/search-assets/llms.txt).)
2. Then provide a predicate and value to search. The Python SDK provides `CompoundQuery.asset_type()` and `CompoundQuery.asset_types()` to restrict assets to one or more specific types.

```python title="Run the search"
client = AtlanClient()
for result in client.asset.search(index): # (1)
 type_name = result.type_name # (2)
```

1. For details, see [Searching for assets](https://docs.atlan.com/llms/platform/python/search-assets/llms.txt).
2. The type name can be retrieved from a result through `.type_name`.

### Kotlin

```kotlin showLineNumbers title="Build the query and request"
val index = client.assets.select() // (1)
 .where(Asset.TYPE_NAME.eq(GlossaryTerm.TYPE_NAME)) // (2)
 .toRequest()
```

1. You can search across all assets using the `select()` method of the `assets` member on any client. (For details, see [Searching for assets](https://docs.atlan.com/llms/platform/python/search-assets/llms.txt).)
2. Then provide a predicate and value to search. The Java SDK provides `Asset.TYPE_NAME.eq()` and `Asset.TYPE_NAME.in()` to restrict assets to one or more specific types.

 ```kotlin title="Equivalent query from Elastic"
 val byType = TermQuery.of(t -> t
 .field("__typeName.keyword")
 .value(GlossaryTerm.TYPE_NAME))
 ._toQuery()
 ```

```kotlin title="Run the search"
for (result in index.search(client))
```

1. For details, see [Searching for assets](https://docs.atlan.com/llms/platform/python/search-assets/llms.txt).
2. The type name can be retrieved from a result through `.typeName`.

### Raw REST API

```json showLineNumbers title="POST /api/meta/search/indexsearch"
{
 "dsl": {
 "query": {
 "term": { "__typeName.keyword": "AtlasGlossaryTerm" } // (1)
 }
 },
 "attributes": [ "__typeName" ]
}
```

1. You can use a [term query](https://docs.atlan.com/llms/platform/python/term-level/llms.txt) to exactly match the type.

```json showLineNumbers title="Response"
{
 "entities": [
 {
 "typeName": "AtlasGlossaryTerm",
 "attributes": {
 "__typeName": "AtlasGlossaryTerm"
 }
 }
 ]
}
```

## `Asset.SUPER_TYPE_NAMES` [](/product/capabilities/build-apps/sdks/python/search/references/searchable-fields#keyword "Keyword") [](/product/capabilities/build-apps/sdks/python/search/references/searchable-fields#text "Text")

All super types of an asset.

For example:

- `Table` has super types of `SQL`, `Catalog`, `Asset` and `Referenceable`.
- `LookerField` has super types of `Looker`, `BI`, `Catalog`, `Asset` and `Referenceable`.

### Java

```java showLineNumbers title="Build the query and request"
IndexSearchRequest index = client.assets.select() // (1)
 .where(Asset.SUPER_TYPE_NAMES.eq(ISQL.TYPE_NAME)) // (2)
 .toRequest();
```

1. You can search across all assets using the `select()` method of the `assets` member on any client. (For details, see [Searching for assets](https://docs.atlan.com/llms/platform/python/search-assets/llms.txt).)
2. Then provide a predicate and value to search. The Java SDK provides `Asset.SUPER_TYPE_NAMES.eq()` and `Asset.SUPER_TYPE_NAMES.in()` to restrict assets to subtypes of one or more specific supertypes.

 :::tip[In the Java SDK, supertypes are interfaces]
Note that in the Java SDK, you can find the type name for most supertypes through an interface (prefixing `I` in front of the supertype name to get the appropriate Java interface class).
 :::
 ```java title="Equivalent query from Elastic"
 Query bySuperType = TermQuery.of(t -> t
 .field("__superTypeNames.keyword")
 .value(ISQL.TYPE_NAME))
 ._toQuery();
 ```

```java title="Run the search"
for (Asset result : index.search(client))
```

1. For details, see [Searching for assets](https://docs.atlan.com/llms/platform/python/search-assets/llms.txt).
2. The type name can be retrieved from a result through `.getTypeName()`. Note that in this example the results list will contain all subtypes of `SQL`: databases, schemas, tables, views, columns, and so on.

### Python

```python showLineNumbers title="Build the query and request"
from pyatlan.client.atlan import AtlanClient
from pyatlan.model.assets import Asset, SQL
from pyatlan.model.fluent_search import CompoundQuery, FluentSearch

index = (FluentSearch() # (1)
 .where(CompoundQuery.super_types(SQL)) # (2)
 ).to_request()
```

1. You can search across all assets using a `FluentSearch()` object. (For details, see [Searching for assets](https://docs.atlan.com/llms/platform/python/search-assets/llms.txt).)
2. Then provide a predicate and value to search. The Python SDK provides `CompoundQuery.super_types()` to restrict assets to subtypes of one or more specific supertypes.

```python title="Run the search"
client = AtlanClient()
for result in client.asset.search(index): # (1)
 type_name = result.type_name # (2)
```

1. For details, see [Searching for assets](https://docs.atlan.com/llms/platform/python/search-assets/llms.txt).
2. The type name can be retrieved from a result through `.type_name`. Note that in this example the results list will contain all subtypes of `SQL`: databases, schemas, tables, views, columns, and so on.

### Kotlin

```kotlin showLineNumbers title="Build the query and request"
val index = client.assets.select() // (1)
 .where(Asset.SUPER_TYPE_NAMES.eq(ISQL.TYPE_NAME)) // (2)
 .toRequest()
```

1. You can search across all assets using the `select()` method of the `assets` member on any client. (For details, see [Searching for assets](https://docs.atlan.com/llms/platform/python/search-assets/llms.txt).)
2. Then provide a predicate and value to search. The Java SDK provides `Asset.SUPER_TYPE_NAMES.eq()` and `Asset.SUPER_TYPE_NAMES.in()` to restrict assets to subtypes of one or more specific supertypes.

 :::tip[In the Java SDK, supertypes are interfaces]
Note that in the Java SDK, you can find the type name for most supertypes through an interface (prefixing `I` in front of the supertype name to get the appropriate Java interface class).
 :::
 ```kotlin title="Equivalent query from Elastic"
 val bySuperType = TermQuery.of(t -> t
 .field("__superTypeNames.keyword")
 .value(ISQL.TYPE_NAME))
 ._toQuery()
 ```

```kotlin title="Run the search"
for (result in index.search(client))
```

1. For details, see [Searching for assets](https://docs.atlan.com/llms/platform/python/search-assets/llms.txt).
2. The type name can be retrieved from a result through `.typeName`. Note that in this example the results list will contain all subtypes of `SQL`: databases, schemas, tables, views, columns, and so on.

### Raw REST API

```json showLineNumbers title="POST /api/meta/search/indexsearch"
{
 "dsl": {
 "query": {
 "term": { "__superTypeNames.keyword": "SQL" } // (1)
 }
 },
 "attributes": [ "__superTypeNames" ]
}
```

1. You can use a [term query](https://docs.atlan.com/llms/platform/python/term-level/llms.txt) to exactly match the type.

```json showLineNumbers title="Response"
{
 "entities": [
 {
 "typeName": "Query"
 },
 {
 "typeName": "Table"
 },
 {
 "typeName": "Database"
 },
 {
 "typeName": "Column"
 }
 ]
}
```

> *Details — see full content on the documentation site.*

## `Asset.HAS_LINEAGE` [](/product/capabilities/build-apps/sdks/python/search/references/searchable-fields#boolean "Boolean")

Flag that's true if an asset has at least one process upstream or downstream. Otherwise, it will be false.

:::warning[Processes are also included]
`Process` assets themselves will also be included in the `true` results, unless excluded by some other search criteria.
:::

### Java

```java showLineNumbers title="Build the query and request"
IndexSearchRequest index = client.assets.select() // (1)
 .where(Asset.HAS_LINEAGE.eq(true)) // (2)
 .includeOnResults(Asset.HAS_LINEAGE) // (3)
 .toRequest();
```

1. You can search across all assets using the `select()` method of the `assets` member on any client. (For details, see [Searching for assets](https://docs.atlan.com/llms/platform/python/search-assets/llms.txt).)
2. Then provide a predicate and value to search. In this example the `eq()` predicate looks for any assets with the lineage flag set to `true`. This uses a [term query](https://docs.atlan.com/llms/platform/python/term-level/llms.txt) to exactly match a `true` value.

 ```java title="Equivalent query from Elastic"
 Query byLineage = TermQuery.of(t -> t
 .field("__hasLineage")
 .value(true))
 ._toQuery();
 ```

3. To make sure the details of this field are included in each result, add the field to `includeOnResults()`.

```java title="Run the search"
for (Asset result : index.search(client))
```

1. For details, see [Searching for assets](https://docs.atlan.com/llms/platform/python/search-assets/llms.txt).
2. The lineage status can be retrieved from a result through `.getHasLineage()`.

### Python

```python showLineNumbers title="Build the query and request"
from pyatlan.client.atlan import AtlanClient
from pyatlan.model.assets import Asset
from pyatlan.model.fluent_search import FluentSearch

index = (FluentSearch() # (1)
 .where(Asset.HAS_LINEAGE.eq(True)) # (2)
 .include_on_results(Asset.HAS_LINEAGE) # (3)
 ).to_request()
```

1. You can search across all assets using a `FluentSearch()` object. (For details, see [Searching for assets](https://docs.atlan.com/llms/platform/python/search-assets/llms.txt).)
2. Then provide a predicate and value to search. In this example the `eq()` predicate looks for any assets with the lineage flag set to `True`. This uses a [term query](https://docs.atlan.com/llms/platform/python/term-level/llms.txt) to exactly match a `True` value.
3. To make sure the details of this field are included in each result, add the field to `include_on_results()`.

```python title="Run the search"
client = AtlanClient()
for result in client.asset.search(index): # (1)
 has_lineage = result.has_lineage # (2)
```

1. For details, see [Searching for assets](https://docs.atlan.com/llms/platform/python/search-assets/llms.txt).
2. The lineage status can be retrieved from a result through `.has_lineage`.

### Kotlin

```kotlin showLineNumbers title="Build the query and request"
val index = client.assets.select() // (1)
 .where(Asset.HAS_LINEAGE.eq(true)) // (2)
 .includeOnResults(Asset.HAS_LINEAGE) // (3)
 .toRequest()
```

1. You can search across all assets using the `select()` method of the `assets` member on any client. (For details, see [Searching for assets](https://docs.atlan.com/llms/platform/python/search-assets/llms.txt).)
2. Then provide a predicate and value to search. In this example the `eq()` predicate looks for any assets with the lineage flag set to `true`. This uses a [term query](https://docs.atlan.com/llms/platform/python/term-level/llms.txt) to exactly match a `true` value.

 ```kotlin title="Equivalent query from Elastic"
 val byLineage = TermQuery.of(t -> t
 .field("__hasLineage")
 .value(true))
 ._toQuery()
 ```

3. To make sure the details of this field are included in each result, add the field to `includeOnResults()`.

```kotlin title="Run the search"
for (result in index.search(client))
```

1. For details, see [Searching for assets](https://docs.atlan.com/llms/platform/python/search-assets/llms.txt).
2. The lineage status can be retrieved from a result through `.hasLineage`.

### Raw REST API

```json showLineNumbers title="POST /api/meta/search/indexsearch"
{
 "dsl": {
 "query": {
 "term": { "__hasLineage": true } // (1)
 }
 },
 "attributes": [ "__hasLineage" ]
}
```

1. You can use a [term query](https://docs.atlan.com/llms/platform/python/term-level/llms.txt) to exactly match the boolean value.

```json showLineNumbers title="Response"
{
 "entities": [
 {
 "attributes": {
 "__hasLineage": true
 }
 }
 ]
}
```

## `Asset.QUALIFIED_NAME` [](/product/capabilities/build-apps/sdks/python/search/references/searchable-fields#keyword "Keyword") [](/product/capabilities/build-apps/sdks/python/search/references/searchable-fields#text "Text") {#assetqualified_name}

The unique fully-qualified name of any asset in Atlan.

Qualified names are often constructed from the identity characteristics of an asset. For example, included in a database's `qualifiedName` is the connection that crawled the database. (And included in a schema's `qualifiedName` is the database it exists in, and therefore it *also* implicitly includes the connection's `qualifiedName` since the database's `qualifiedName` includes it.)

### Java

```java showLineNumbers title="Build the query and request"
IndexSearchRequest index = client.assets.select() // (1)
 .where(Asset.QUALIFIED_NAME.startsWith("default/snowflake/1662194632")) // (2)
 .includeOnResults(Asset.QUALIFIED_NAME) // (3)
 .toRequest();
```

1. You can search across all assets using the `select()` method of the `assets` member on any client. (For details, see [Searching for assets](https://docs.atlan.com/llms/platform/python/search-assets/llms.txt).)
2. Then provide a predicate and value to search. In this example the `startsWith()` predicate looks for any value that starts with the provided string, in this case matching any assets within this connection. This uses a [prefix query](https://docs.atlan.com/llms/platform/python/term-level/llms.txt) to match values that start with a particular string rather than the entire value.

 ```java title="Equivalent query from Elastic"
 Query byQN = PrefixQuery.of(p -> p
 .field("qualifiedName")
 .value("default/snowflake/1662194632"))
 ._toQuery();
 ```

3. To make sure the details of this field are included in each result, add the field to `includeOnResults()`.

```java title="Run the search"
for (Asset result : index.search(client))
```

1. For details, see [Searching for assets](https://docs.atlan.com/llms/platform/python/search-assets/llms.txt).
2. The `qualifiedName` can be retrieved from a result through `.getQualifiedName()`.

### Python

```python showLineNumbers title="Build the query and request"
from pyatlan.client.atlan import AtlanClient
from pyatlan.model.assets import Asset
from pyatlan.model.fluent_search import FluentSearch

index = (FluentSearch() # (1)
 .where(Asset.QUALIFIED_NAME.startswith("default/snowflake/1662194632")) # (2)
 .include_on_results(Asset.QUALIFIED_NAME) # (3)
 ).to_request()
```

1. You can search across all assets using a `FluentSearch()` object. (For details, see [Searching for assets](https://docs.atlan.com/llms/platform/python/search-assets/llms.txt).)
2. Then provide a predicate and value to search. In this example the `startswith()` predicate looks for any value that starts with the provided string, in this case matching any assets within this connection. This uses a [prefix query](https://docs.atlan.com/llms/platform/python/term-level/llms.txt) to match values that start with a particular string rather than the entire value.
3. To make sure the details of this field are included in each result, add the field to `include_on_results()`.

```python title="Run the search"
client = AtlanClient()
for result in client.asset.search(index): # (1)
 qualified_name = result.qualified_name # (2)
```

1. For details, see [Searching for assets](https://docs.atlan.com/llms/platform/python/search-assets/llms.txt).
2. The `qualified_name` can be retrieved from a result through `.qualified_name`.

### Kotlin

```kotlin showLineNumbers title="Build the query and request"
val index = client.assets.select() // (1)
 .where(Asset.QUALIFIED_NAME.startsWith("default/snowflake/1662194632")) // (2)
 .includeOnResults(Asset.QUALIFIED_NAME) // (3)
 .toRequest()
```

1. You can search across all assets using the `select()` method of the `assets` member on any client. (For details, see [Searching for assets](https://docs.atlan.com/llms/platform/python/search-assets/llms.txt).)
2. Then provide a predicate and value to search. In this example the `startsWith()` predicate looks for any value that starts with the provided string, in this case matching any assets within this connection. This uses a [prefix query](https://docs.atlan.com/llms/platform/python/term-level/llms.txt) to match values that start with a particular string rather than the entire value.

 ```kotlin title="Equivalent query from Elastic"
 val byQN = PrefixQuery.of(p -> p
 .field("qualifiedName")
 .value("default/snowflake/1662194632"))
 ._toQuery()
 ```

3. To make sure the details of this field are included in each result, add the field to `includeOnResults()`.

```kotlin title="Run the search"
for (result in index.search(client))
```

1. For details, see [Searching for assets](https://docs.atlan.com/llms/platform/python/search-assets/llms.txt).
2. The `qualifiedName` can be retrieved from a result through `.qualifiedName`.

### Raw REST API

```json showLineNumbers title="POST /api/meta/search/indexsearch"
{
 "dsl": {
 "query": {
 "prefix": { "qualifiedName": "default/snowflake/1662194632" } // (1)
 }
 },
 "attributes": [ "qualifiedName" ]
}
```

1. You can use a [prefix query](https://docs.atlan.com/llms/platform/python/term-level/llms.txt) to find all the objects in a connection, based on the qualifiedName.

```json showLineNumbers title="Response"
{
 "entities": [
 {
 "attributes": {
 "qualifiedName": "default/snowflake/1662194632" //(1)
 }
 },
 {
 "attributes": {
 "qualifiedName": "default/snowflake/1662194632/SAMPLEDB" // (2)
 }
 }
 ]
}
```

1. When searching on prefix you'll get exact matches...
2. ...and also matches of any other objects whose value for that attribute *starts with* the prefix value.

## `Asset.NAME` [](/product/capabilities/build-apps/sdks/python/search/references/searchable-fields#keyword "Keyword") [](/product/capabilities/build-apps/sdks/python/search/references/searchable-fields#text "Text")

The name of the asset in Atlan, as it appears in the UI.

### Java

```java showLineNumbers title="Build the query and request"
IndexSearchRequest index = client.assets.select() // (1)
 .where(Asset.NAME.eq("dev", true)) // (2)
 .includeOnResults(Asset.NAME) // (3)
 .toRequest();
```

1. You can search across all assets using the `select()` method of the `assets` member on any client. (For details, see [Searching for assets](https://docs.atlan.com/llms/platform/python/search-assets/llms.txt).)
2. Then provide a predicate and value to search. In this example the `eq()` predicate looks for an exact match (case-insensitively). This uses a [term query](https://docs.atlan.com/llms/platform/python/term-level/llms.txt) to exactly match the names, but ignores case due to the second parameter being `true`.

 ```java title="Equivalent query from Elastic"
 Query byName = TermQuery.of(t -> t
 .field("name.keyword")
 .value("dev")
 .caseInsensitive(true))
 ._toQuery();
 ```

3. To make sure the details of this field are included in each result, add the field to `includeOnResults()`.

```java title="Run the search"
for (Asset result : index.search(client))
```

1. For details, see [Searching for assets](https://docs.atlan.com/llms/platform/python/search-assets/llms.txt).
2. The `name` can be retrieved from a result through `.getName()`.

### Python

```python showLineNumbers title="Build the query and request"
from pyatlan.client.atlan import AtlanClient
from pyatlan.model.assets import Asset
from pyatlan.model.fluent_search import FluentSearch

index = (FluentSearch() # (1)
 .where(Asset.NAME.eq("dev", case_insensitive=True)) # (2)
 .include_on_results(Asset.NAME) # (3)
 ).to_request()
```

1. You can search across all assets using a `FluentSearch()` object. (For details, see [Searching for assets](https://docs.atlan.com/llms/platform/python/search-assets/llms.txt).)
2. Then provide a predicate and value to search. In this example the `eq()` predicate looks for an exact match (case-insensitively). This uses a [term query](https://docs.atlan.com/llms/platform/python/term-level/llms.txt) to exactly match the names, but ignores case due to the second parameter being `true`.
3. To make sure the details of this field are included in each result, add the field to `include_on_results()`.

```python title="Run the search"
client = AtlanClient()
for result in client.asset.search(index): # (1)
 name = result.name # (2)
```

1. For details, see [Searching for assets](https://docs.atlan.com/llms/platform/python/search-assets/llms.txt).
2. The `name` can be retrieved from a result through `.name`.

### Kotlin

```kotlin showLineNumbers title="Build the query and request"
val index = client.assets.select() // (1)
 .where(Asset.NAME.eq("dev", true)) // (2)
 .includeOnResults(Asset.NAME) // (3)
 .toRequest()
```

1. You can search across all assets using the `select()` method of the `assets` member on any client. (For details, see [Searching for assets](https://docs.atlan.com/llms/platform/python/search-assets/llms.txt).)
2. Then provide a predicate and value to search. In this example the `eq()` predicate looks for an exact match (case-insensitively). This uses a [term query](https://docs.atlan.com/llms/platform/python/term-level/llms.txt) to exactly match the names, but ignores case due to the second parameter being `true`.

 ```kotlin title="Equivalent query from Elastic"
 val byName = TermQuery.of(t -> t
 .field("name.keyword")
 .value("dev")
 .caseInsensitive(true))
 ._toQuery()
 ```

3. To make sure the details of this field are included in each result, add the field to `includeOnResults()`.

```kotlin title="Run the search"
for (result in index.search(client))
```

1. For details, see [Searching for assets](https://docs.atlan.com/llms/platform/python/search-assets/llms.txt).
2. The `name` can be retrieved from a result through `.name`.

### Raw REST API

```json showLineNumbers title="POST /api/meta/search/indexsearch"
{
 "dsl": {
 "query": {
 "term": { "name.keyword": { "value": "dev" }} // (1)
 }
 },
 "attributes": [ "name" ]
}
```

1. A [term query](https://docs.atlan.com/llms/platform/python/term-level/llms.txt) on the keyword index will only match results whose name is *exactly* `dev`—not `development` or `developer` or any other variation.

```json showLineNumbers title="Response"
{
 "entities": [
 {
 "attributes": {
 "name": "dev"
 }
 }
 ]
}
```

---