---
title: "Sort Query Results"
url: "https://docs.ravendb.net/6.2/client-api/session/querying/sort-query-results"
version: "6.2"
language: "csharp"
---

# Sort Query Results

> Client language: C#. Also available for [Python](https://docs.ravendb.net/6.2/client-api/session/querying/sort-query-results.python.md), [PHP](https://docs.ravendb.net/6.2/client-api/session/querying/sort-query-results.php.md), [Node.js](https://docs.ravendb.net/6.2/client-api/session/querying/sort-query-results.nodejs.md).
>
> RavenDB publishes an official agent skill for coding assistants at https://docs.ravendb.net/skills/ravendb/SKILL.md (also installable with `npx skills add ravendb/skills`). The skill describes itself as: "Read this before writing any RavenDB query, client call or /databases/ request. Covers server setup, document modelling, the Node.js, .NET and Python clients, RQL, indexes, vector search and AI agents. Code written from recall tends to run and return the wrong rows, because RQL resembles SQL and the clients take field names as plain strings."

> **Note**
>
> - When making a query, the server will return the results **sorted** only if explicitly requested by the query.  
>   If no sorting method is specified when issuing the query then results will not be sorted.
>
>   - Note: An exception to the above rule is when [Boosting](https://docs.ravendb.net/6.2/indexes/boosting.md) is involved in the query.  
>     Learn more in [Automatic score-based ordering](https://docs.ravendb.net/6.2/indexes/boosting.md#automatic-score-based-ordering).
>
> - Sorting is applied by the server after the query filtering stage.  
>   Applying filtering is recommended as it reduces the number of results RavenDB needs to sort  
>   when querying a large dataset.
>
> - Multiple sorting actions can be chained.
>
> - This article provides examples of sorting query results when making a **dynamic-query**.  
>   For sorting results when querying a **static-index** see [sort index query results](https://docs.ravendb.net/6.2/indexes/querying/sorting.md).
>
> - In this page:
>   - [Order by field value](#order-by-field-value)
>   - [Order by score](#order-by-score)
>     - [Get resulting score](#get-resulting-score)
>   - [Order by random](#order-by-random)
>   - [Order by spatial](#order-by-spatial)
>   - [Order by count (aggregation query)](#order-by-count-aggregation-query)
>   - [Order by sum (aggregation query)](#order-by-sum-aggregation-query)
>   - [Force ordering type](#force-ordering-type)
>   - [Chain ordering](#chain-ordering)
>   - [Custom sorters](#custom-sorters)
>   - [Syntax](#syntax)

## Order by field value {#order-by-field-value}

- Use `OrderBy` or `OrderByDescending` to order the results by the specified document-field.

- The query is served by an auto-index that includes the sorted field, even when no filtering is applied.  
  For example, `from Employees order by FirstName` uses an auto-index that includes `FirstName`, creating one if needed.  
  Learn more in [Query a collection - with filtering or sorting](https://docs.ravendb.net/6.2/client-api/session/querying/how-to-query.md#dynamicQuery).

### Query

```csharp
List<Product> products = session
     // Make a dynamic query on the Products collection    
    .Query<Product>()
     // Apply filtering (optional)
    .Where(x => x.UnitsInStock > 10)
     // Call 'OrderBy', pass the document-field by which to order the results
    .OrderBy(x => x.UnitsInStock)
    .ToList();

// Results will be sorted by the 'UnitsInStock' value in ascending order,
// with smaller values listed first.
```

### Query\_async

```csharp
List<Product> products = await asyncSession
     // Make a dynamic query on the Products collection    
    .Query<Product>()
     // Apply filtering (optional)
    .Where(x => x.UnitsInStock > 10)
     // Call 'OrderBy', pass the document-field by which to order the results
    .OrderBy(x => x.UnitsInStock)
    .ToListAsync();

// Results will be sorted by the 'UnitsInStock' value in ascending order,
// with smaller values listed first.
```

### DocumentQuery

```csharp
List<Product> products = session.Advanced
     // Make a DocumentQuery on the Products collection    
    .DocumentQuery<Product>()
     // Apply filtering (optional)
    .WhereGreaterThan(x => x.UnitsInStock, 10)
     // Call 'OrderBy', pass the document-field by which to order the results
    .OrderBy(x => x.UnitsInStock)
    .ToList();

// Results will be sorted by the 'UnitsInStock' value in ascending order,
// with smaller values listed first.
```

### RQL

```sql
from "Products"
where UnitsInStock > 10
order by UnitsInStock as long
```

> **Info**
>
> **Ordering Type**:
>
> - By default, the `OrderBy` methods will determine the `OrderingType` from the property path expression  
>   and specify that ordering type in the generated RQL that is sent to the server.
>
> - E.g. in the above example, ordering by `x => x.UnitsInStock` will result in `OrderingType.Long`  
>   because that property data type is an integer.
>
> - Different ordering can be forced - see [Force ordering type](#force-ordering-type) below.

## Order by score {#order-by-score}

- When querying with some filtering conditions, a basic score is calculated for each item in the results  
  by the underlying indexing engine.

- The higher the score value the better the match.

- Use `OrderByScore` or `OrderByScoreDescending` to order by this score.

### Query

```csharp
List<Product> products = session
    .Query<Product>()
     // Apply filtering
    .Where(x => x.UnitsInStock < 5 || x.Discontinued)
     // Call 'OrderByScore'
    .OrderByScore()
    .ToList();

// Results will be sorted by the score value
// with best matching documents (higher score values) listed first.
```

### Query\_async

```csharp
List<Product> products = await asyncSession
    .Query<Product>()
     // Apply filtering
    .Where(x => x.UnitsInStock < 5 || x.Discontinued)
     // Call 'OrderByScore'
    .OrderByScore()
    .ToListAsync();

// Results will be sorted by the score value
// with best matching documents (higher score values) listed first.
```

### DocumentQuery

```csharp
List<Product> products = session.Advanced
    .DocumentQuery<Product>()
     // Apply filtering
    .WhereLessThan(x => x.UnitsInStock, 5)
    .OrElse()
    .WhereEquals(x => x.Discontinued, true)
     // Call 'OrderByScore'
    .OrderByScore()
    .ToList();

// Results will be sorted by the score value
// with best matching documents (higher score values) listed first.
```

### RQL

```sql
from "Products"
where UnitsInStock < 5 or Discontinued == true
order by score()
```

> **Info**
>
> #### Get resulting score:
>
> The score details can be retrieved by either:
>
> - **Request to include explanations**:  
>   You can get the score details and see how it was calculated by requesting to include explanations in the query.
>   Currently, this is only available when using Lucene as the underlying indexing engine.  
>   Learn more in [Include query explanations](https://docs.ravendb.net/6.2/client-api/session/querying/debugging/include-explanations.md).
>
> - **Get score from metadata**:
>
>   - The score is available in the `@index-score` metadata property within each result.  
>     Note the following difference between the underlying indexing engines:
>
>     - When using **Lucene**:  
>       This metadata property is always available in the results.  
>       Read more about Lucene scoring [here](https://lucene.apache.org/core/3_3_0/scoring.html).
>
>     - When using **Corax**:  
>       In order to enhance performance, this metadata property is Not included in the results by default.  
>       To get this metadata property you must set the [Indexing.Corax.IncludeDocumentScore](https://docs.ravendb.net/6.2/server/configuration/indexing-configuration.md#indexingcoraxincludedocumentscore) configuration value to *true*.  
>       Learn about the available methods for setting an indexing configuration key in this [indexing-configuration](https://docs.ravendb.net/6.2/server/configuration/indexing-configuration.md) article.
>
>   - The following example shows how to get the score from the metadata of the resulting entities that were loaded to the session:
>
> ```csharp
> // Make a query:
> // =============
>
> List<Employee> employees = session
>     .Query<Employee>()
>     .Search(x => x.Notes, "English")
>     .Search(x => x.Notes, "Italian", boost: 10)
>     .ToList();
>
> // Get the score:
> // ==============
>
> // Call 'GetMetadataFor', pass an entity from the resulting employees list
> var metadata = session.Advanced.GetMetadataFor(employees[0]);
>
> // Score is available in the '@index-score' metadata property
> var score = metadata[Constants.Documents.Metadata.IndexScore];
> ```

## Order by random {#order-by-random}

- Use `RandomOrdering` to randomize the order of the query results.

- An optional seed parameter can be passed.

### Query

```csharp
List<Product> products = session
    .Query<Product>()
    .Where(x => x.UnitsInStock > 10)
     // Call 'Customize' with 'RandomOrdering'
    .Customize(x => x.RandomOrdering())
     // An optional seed can be passed, e.g.:
     // .Customize(x => x.RandomOrdering('someSeed'))
    .ToList();

// Results will be randomly ordered.
```

### Query\_async

```csharp
List<Product> products = await asyncSession
    .Query<Product>()
    .Where(x => x.UnitsInStock > 10)
     // Call 'Customize' with 'RandomOrdering'
    .Customize(x => x.RandomOrdering())
     // An optional seed can be passed, e.g.:
     // .Customize(x => x.RandomOrdering('someSeed'))
    .ToListAsync();

// Results will be randomly ordered.
```

### DocumentQuery

```csharp
List<Product> products = session.Advanced  
    .DocumentQuery<Product>()
    .WhereGreaterThan(x => x.UnitsInStock, 10)
     // Call 'RandomOrdering'
    .RandomOrdering()
     // An optional seed can be passed, e.g.:
     // .RandomOrdering('someSeed')
    .ToList();

// Results will be randomly ordered.
```

### RQL

```sql
from "Products"
where UnitsInStock > 10
order by random()
// order by random(someSeed)
```

## Order by spatial {#order-by-spatial}

- If your data contains geographical locations,  
  spatial query results can be sorted based on their distance from a specific point.

- See detailed explanation in [Spatial Sorting](https://docs.ravendb.net/6.2/client-api/session/querying/how-to-make-a-spatial-query.md#spatial-sorting).

## Order by count (aggregation query) {#order-by-count-aggregation-query}

- The results of a [group-by query](https://docs.ravendb.net/6.2/client-api/session/querying/how-to-perform-group-by-query.md) can be sorted by the `Count` aggregation operation used in the query.

### Query

```csharp
var numberOfProductsPerCategory = session
    .Query<Product>()
     // Make an aggregation query
    .GroupBy(x => x.Category)
    .Select(x => new
    {
        // Group by Category
        Category = x.Key,
        // Count the number of product documents per category
        Count = x.Count()
    })
     // Order by the Count value
    .OrderBy(x => x.Count)
    .ToList();

// Results will contain the number of Product documents per category
// ordered by that count in ascending order.
```

### Query\_async

```csharp
var numberOfProductsPerCategory = await asyncSession
    .Query<Product>()
     // Make an aggregation query
    .GroupBy(x => x.Category)
    .Select(x => new
    {
        // Group by Category
        Category = x.Key,
        // Count the number of product documents per category
        Count = x.Count()
    })
     // Order by the Count value
    .OrderBy(x => x.Count)
    .ToListAsync();

// Results will contain the number of Product documents per category
// ordered by that count in ascending order.
```

### DocumentQuery

```csharp
var numberOfProductsPerCategory = session.Advanced
    .DocumentQuery<Product>()
     // Group by Category
    .GroupBy("Category")
    .SelectKey("Category")
     // Count the number of product documents per category
    .SelectCount()
     // Order by the Count value
     // Here you need to specify the ordering type explicitly 
    .OrderBy("Count", OrderingType.Long)
    .ToList();

// Results will contain the number of Product documents per category
// ordered by that count in ascending order.
```

### RQL

```sql
from "Products"
group by Category
order by count() as long
select key() as "Category", count()
```

## Order by sum (aggregation query) {#order-by-sum-aggregation-query}

- The results of a [group-by query](https://docs.ravendb.net/6.2/client-api/session/querying/how-to-perform-group-by-query.md) can be sorted by the `Sum` aggregation operation used in the query.

### Query

```csharp
var numberOfUnitsInStockPerCategory = session
    .Query<Product>()
     // Make an aggregation query
    .GroupBy(x => x.Category)
    .Select(x => new
    {
        // Group by Category
        Category = x.Key,
        // Sum the number of units in stock per category
        Sum = x.Sum(x => x.UnitsInStock)
    })
     // Order by the Sum value
    .OrderBy(x => x.Sum)
    .ToList();

// Results will contain the total number of units in stock per category
// ordered by that number in ascending order.
```

### Query\_async

```csharp
var numberOfUnitsInStockPerCategory = await asyncSession
    .Query<Product>()
     // Make an aggregation query
    .GroupBy(x => x.Category)
    .Select(x => new
    {
        // Group by Category
        Category = x.Key,
        // Sum the number of units in stock per category
        Sum = x.Sum(x => x.UnitsInStock)
    })
     // Order by the Sum value
    .OrderBy(x => x.Sum)
    .ToListAsync();

// Results will contain the total number of units in stock per category
// ordered by that number in ascending order.
```

### DocumentQuery

```csharp
var numberOfUnitsInStockPerCategory = session.Advanced
  .DocumentQuery<Product>()
   // Group by Category
  .GroupBy("Category")
  .SelectKey("Category")
   // Sum the number of units in stock per category
  .SelectSum(new GroupByField
  {
      FieldName = "UnitsInStock",
      ProjectedName = "Sum"
  })
   // Order by the Sum value
   // Here you need to specify the ordering type explicitly 
  .OrderBy("Sum", OrderingType.Long)
  .ToList();

// Results will contain the total number of units in stock per category
// ordered by that number in ascending order.
```

### RQL

```sql
from "Products"
group by Category
order by Sum as long
select key() as 'Category', sum(UnitsInStock) as Sum
```

## Force ordering type {#force-ordering-type}

- By default, the `OrderBy` methods will determine the `OrderingType` from the property path expression  
  and specify that ordering type in the generated RQL that is sent to the server.

- A different ordering can be forced by passing the ordering type explicitly to `OrderBy` or `OrderByDescending`.

- The following ordering types are available:

  - `OrderingType.Long`
  - `OrderingType.Double`
  - `OrderingType.AlphaNumeric`
  - `OrderingType.String` (lexicographic ordering)

- When using RQL directly, if no ordering type is specified, then the server defaults to lexicographic ordering.

> **Note**
>
> **Using alphanumeric ordering example**:
>
> - When ordering mixed-character strings by the default lexicographical ordering  
>   then comparison is done character by character based on the Unicode values.  
>   For example, "Abc9" will come after "Abc10" since 9 is greater than 1.
>
> - If you want the digit characters to be ordered as numbers then use alphanumeric ordering  
>   where "Abc10" will result after "Abc9".
>
> ### Query
>
> ```csharp
> List<Product> products = session
>     .Query<Product>()
>      // Call 'OrderBy', order by field 'QuantityPerUnit'
>      // Pass a second param, requesting to order the text alphanumerically
>     .OrderBy(x => x.QuantityPerUnit, OrderingType.AlphaNumeric)
>     .ToList();
> ```
>
> ### Query\_async
>
> ```csharp
> List<Product> products = await asyncSession
>     .Query<Product>()
>      // Call 'OrderBy', order by field 'QuantityPerUnit'
>      // Pass a second param, requesting to order the text alphanumerically
>     .OrderBy(x => x.QuantityPerUnit, OrderingType.AlphaNumeric)
>     .ToListAsync();
> ```
>
> ### DocumentQuery
>
> ```csharp
> List<Product> products = session.Advanced
>     .DocumentQuery<Product>()
>      // Call 'OrderBy', order by field 'QuantityPerUnit'
>      // Pass a second param, requesting to order the text alphanumerically
>     .OrderBy(x => x.QuantityPerUnit, OrderingType.AlphaNumeric)
>     .ToList();
> ```
>
> ### RQL
>
> ```sql
> from "Products"
> order by QuantityPerUnit as alphanumeric
> ```
>
> ```csharp
> // Running the above query on the NorthWind sample data,
> // would produce the following order for the QuantityPerUnit field:
> // ================================================================
>
> // "1 kg pkg."
> // "1k pkg."
> // "2 kg box."
> // "4 - 450 g glasses"
> // "5 kg pkg."
> // ...
>
> // While running with the default Lexicographical ordering would have produced:
> // ============================================================================
>
> // "1 kg pkg."
> // "10 - 200 g glasses"
> // "10 - 4 oz boxes"
> // "10 - 500 g pkgs."
> // "10 - 500 g pkgs."
> // ...
> ```

## Chain ordering {#chain-ordering}

- It is possible to chain multiple orderings in the query.  
  Any combination of secondary sorting is possible as the fields are indexed independently of one another.

- This is achieved by using the `ThenBy` (`ThenByDescending`) and `ThenByScore` (`ThenByScoreDescending`) methods.

- **When using the Lucene search engine** -  
  there is no limit on the number of sorting actions that can be chained in a query.

  **When using the Corax search engine** -  
  a maximum of `16` *order by* clauses is allowed per query. If this limit is exceeded, an exception will be thrown.  
  To resolve this, simplify your query or switch to the Lucene engine. See [Selecting the search engine](https://docs.ravendb.net/6.2/indexes/search-engine/corax.md#selecting-the-search-engine).

### Query

```csharp
List<Product> products = session
    .Query<Product>()
    .Where(x => x.UnitsInStock > 10)
     // Apply the primary sort by 'UnitsInStock'
    .OrderByDescending(x => x.UnitsInStock)
     // Apply a secondary sort by the score (for products with the same # of units in stock)
    .ThenByScore()
     // Apply another sort by 'Name' (for products with same # of units in stock and same score)
    .ThenBy(x => x.Name)
    .ToList();

// Results will be sorted by the 'UnitsInStock' value (descending),
// then by score,
// and then by 'Name' (ascending).
```

### Query\_async

```csharp
List<Product> products = await asyncSession
    .Query<Product>()
    .Where(x => x.UnitsInStock > 10)
     // Apply the primary sort by 'UnitsInStock'
    .OrderByDescending(x => x.UnitsInStock)
     // Apply a secondary sort by the score (for products with the same # of units in stock)
    .ThenByScore()
     // Apply another sort by 'Name' (for products with same # of units in stock and same score)
    .ThenBy(x => x.Name)
    .ToListAsync();

// Results will be sorted by the 'UnitsInStock' value (descending),
// then by score,
// and then by 'Name' (ascending).
```

### DocumentQuery

```csharp
List<Product> products = session.Advanced
    .DocumentQuery<Product>()
    .WhereGreaterThan(x => x.UnitsInStock, 10)
     // Apply the primary sort by 'UnitsInStock'
    .OrderByDescending(x => x.UnitsInStock)
     // Apply a secondary sort by the score
    .OrderByScore()
     // Apply another sort by 'Name'
    .OrderBy(x => x.Name)
    .ToList();

// Results will be sorted by the 'UnitsInStock' value (descending),
// then by score,
// and then by 'Name' (ascending).
```

### RQL

```sql
from "Products"
where UnitsInStock > 10
order by UnitsInStock as long desc, score(), Name
```

## Custom sorters {#custom-sorters}

- The Lucene indexing engine allows you to create your own custom sorters.  
  Custom sorters are not supported by [Corax](https://docs.ravendb.net/6.2/indexes/search-engine/corax.md).

- Custom sorters can be deployed to the server by either:

  - Sending the [Put Sorters Operation](https://docs.ravendb.net/6.2/client-api/operations/maintenance/sorters/put-sorter.md) from your code.

  - Uploading a custom sorter from Studio, see [Custom Sorters View](https://docs.ravendb.net/6.2/studio/database/settings/custom-sorters.md).

- Once the custom sorter is deployed, you can sort the query results with it.

### Query

```csharp
List<Product> products = session
    .Query<Product>()
    .Where(x => x.UnitsInStock > 10)
     // Order by field 'UnitsInStock', pass the name of your custom sorter class
    .OrderBy(x => x.UnitsInStock, "MySorter")
    .ToList();

// Results will be sorted by the 'UnitsInStock' value
// according to the logic from 'MySorter' class
```

### Query\_async

```csharp
List<Product> products = await asyncSession
    .Query<Product>()
    .Where(x => x.UnitsInStock > 10)
     // Order by field 'UnitsInStock', pass the name of your custom sorter class
    .OrderBy(x => x.UnitsInStock, "MySorter")
    .ToListAsync();

// Results will be sorted by the 'UnitsInStock' value
// according to the logic from 'MySorter' class
```

### DocumentQuery

```csharp
List<Product> products = session.Advanced
    .DocumentQuery<Product>()
    .WhereGreaterThan(x => x.UnitsInStock, 10)
     // Order by field 'UnitsInStock', pass the name of your custom sorter class
    .OrderBy(x => x.UnitsInStock, "MySorter")
    .ToList();

// Results will be sorted by the 'UnitsInStock' value
// according to the logic from 'MySorter' class
```

### RQL

```sql
from "Products"
where UnitsInStock > 10
order by custom(UnitsInStock, "MySorter")
```

## Syntax {#syntax}

```csharp
// OrderBy overloads:
IOrderedQueryable<T> OrderBy<T>(string path, OrderingType ordering);
IOrderedQueryable<T> OrderBy<T>(Expression<Func<T, object>> path, OrderingType ordering);
IOrderedQueryable<T> OrderBy<T>(string path, string sorterName);
IOrderedQueryable<T> OrderBy<T>(Expression<Func<T, object>> path, string sorterName);

// OrderByDescending overloads:
IOrderedQueryable<T> OrderByDescending<T>(string path, OrderingType ordering);
IOrderedQueryable<T> OrderByDescending<T>(Expression<Func<T, object>> path, OrderingType ordering);
IOrderedQueryable<T> OrderByDescending<T>(string path, string sorterName);
IOrderedQueryable<T> OrderByDescending<T>(Expression<Func<T, object>> path, string sorterName);
```

| Parameter | Type | Description |
| - | - | - |
| **path** | `string` | The name of the field to sort by |
| **path** | `Expression<Func<T, object>>` | A lambda expression to the field by which to sort |
| **ordering** | `QueryStatistics` | The ordering type that will be used to sort the results:<br />`OrderingType.Long`<br />`OrderingType.Double`<br />`OrderingType.AlphaNumeric`<br />`OrderingType.String` (default) |
| **sorterName** | `string` | The name of your custom sorter class |

## See also

- [Query Overview](https://docs.ravendb.net/6.2/client-api/session/querying/how-to-query.md)
- [Customize query](https://docs.ravendb.net/6.2/client-api/session/querying/how-to-customize-query.md)
- [Group by query](https://docs.ravendb.net/6.2/client-api/session/querying/how-to-perform-group-by-query.md)
- [Spatial query](https://docs.ravendb.net/6.2/client-api/session/querying/how-to-make-a-spatial-query.md)
- [Full-text search](https://docs.ravendb.net/6.2/client-api/session/querying/text-search/full-text-search.md)
