Sorting search results

You can sort search results by one or multiple properties.

Limited to iterating through less than 100,000 results

You can sort any number of results; however, if you plan to page through more than 100,000 total results you can't specify any sort order.

Java
Python
Kotlin
Raw REST API

Annotated sort options, as you would define them in the Java SDK
SortOptions byUpdate = Asset.UPDATE_TIME.order(SortOrder.Desc); // (1)
SortOptions byCreation = Asset.CREATE_TIME.order(SortOrder.Asc); // (2)

For each property you can specify whether to sort the results in descending order or ascending order. In this example our first results would be the ones changed most recently.
Equivalent sort option from Elastic
```
SortOptions byUpdate = SortOptions.of(s -> s
    .field(FieldSort.of(f -> f // (1)
        .field("__modificationTimestamp")
        .order(SortOrder.Desc))));
```

In this example, our first results would be the oldest ones (based on when they were created).

Equivalent sort option from Elastic
SortOptions byCreation = SortOptions.of(s -> s
    .field(FieldSort.of(f -> f // (2)
        .field("__timestamp")
        .order(SortOrder.Asc))));

Build the request
IndexSearchRequest index = client.assets.select()
    .where(...) // (1)
    .sort(byUpdate) // (2)
    .sort(byCreation) // (3)
    .toRequest();

You still need a query, to get some results to sort.
Note that the sort itself is an array—hence we can add multiple sort options and they'll be evaluated in order (to sort by multiple properties). In this example our first results would be the ones changed most recently.
For any results that have identical modification dates, we would then sort within those results to present the oldest (created) results first.

Run the search
IndexSearchResponse response = index.search(client);
for (Asset result : response)

Annotated sort options, as you would define them in the Python SDK
from pyatlan.client.atlan import AtlanClient
from pyatlan.model.enums import SortOrder
from pyatlan.model.assets import Referenceable
from pyatlan.model.search import IndexSearchRequest, DSL

by_update = Referenceable.UPDATE_TIME.order(SortOrder.DESCENDING)  # (1)
by_creation = Referenceable.CREATE_TIME.order(SortOrder.ASCENDING)  # (2)

For each property you can specify whether to sort the results in descending order or ascending order. In this example our first results would be the ones changed most recently.
In this example, our first results would be the oldest ones (based on when they were created).

Build the request
index = (
    FluentSearch()
    .where(...)  # (1)
    .sort(by_update)  # (2)
    .sort(by_creation)  # (3)
).to_request()

You still need a query, to get some results to sort.
Note that the sort itself is an array—hence we can add multiple sort options and they'll be evaluated in order (to sort by multiple properties). In this example our first results would be the ones changed most recently.
For any results that have identical modification dates, we would then sort within those results to present the oldest (created) results first.

Run the search
client = AtlanClient();
response = client.asset.search(index)
for result in response:
    # Do something with the ordered results...

Annotated sort options, as you would define them in the Java SDK
val byUpdate = Asset.UPDATE_TIME.order(SortOrder.Desc) // (1)
val byCreation = Asset.CREATE_TIME.order(SortOrder.Asc) // (2)

For each property you can specify whether to sort the results in descending order or ascending order. In this example our first results would be the ones changed most recently.
Equivalent sort option from Elastic
```
val byUpdate = SortOptions.of(s -> s
    .field(FieldSort.of(f -> f // (1)
        .field("__modificationTimestamp")
        .order(SortOrder.Desc))))
```

In this example, our first results would be the oldest ones (based on when they were created).

Equivalent sort option from Elastic
val byCreation = SortOptions.of(s -> s
    .field(FieldSort.of(f -> f // (2)
        .field("__timestamp")
        .order(SortOrder.Asc))))

Build the request
val index = client.assets.select()
    .where(...) // (1)
    .sort(byUpdate) // (2)
    .sort(byCreation) // (3)
    .toRequest()

You still need a query, to get some results to sort.
Note that the sort itself is an array—hence we can add multiple sort options and they'll be evaluated in order (to sort by multiple properties). In this example our first results would be the ones changed most recently.
For any results that have identical modification dates, we would then sort within those results to present the oldest (created) results first.

Run the search
val response = index.search(client)
for (result in response)

POST /api/meta/search/indexsearch
{
  "dsl": {
    "query": {...}, // (1)
    "sort": [ // (2)}, // (3)} // (4)
    ]
  }
}

You still need a query, to get some results to sort.
Note that the sort itself is an array—hence you can sort by multiple properties.
For each property you can specify whether to sort the results in descending order or ascending order. In this example our first results would be the ones changed most recently.
For any results that have identical modification dates, we would then sort within those results to present the oldest (created) results first.

See Elastic's documentation for more details

The examples above should cover most scenarios. If you want to get fancy, see Elastic's documentation on sorting.