Docs
Elasticsearch.Net and NEST: the .NET clients [6.x] » Search » Sort Usage
«  Sliced Scroll Search Usage     Source Filtering Usage  »

Sort Usageedit

Allows to add one or more sort on specific fields. Each sort can be reversed as well. The sort is defined on a per field level, with special field name for _score to sort by score.

Fluent DSL exampleedit

s => s
.Sort(ss => ss
    .Ascending(p => p.StartedOn)
    .Descending(p => p.Name)
    .Descending(SortSpecialField.Score)
    .Ascending(SortSpecialField.DocumentIndexOrder)
    .Field(f => f
        .Field(p => p.Tags.First().Added)
        .Order(SortOrder.Descending)
        .MissingLast()
        .UnmappedType(FieldType.Date)
        .Mode(SortMode.Average)
        .NestedPath(p => p.Tags)
        .NestedFilter(q => q.MatchAll())
    )
    .Field(f => f
        .Field(p => p.NumberOfCommits)
        .Order(SortOrder.Descending)
        .Missing(-1)
    )
    .GeoDistance(g => g
        .Field(p => p.Location)
        .DistanceType(GeoDistanceType.Arc)
        .Order(SortOrder.Ascending)
        .Unit(DistanceUnit.Centimeters)
        .Mode(SortMode.Min)
        .Points(new GeoLocation(70, -70), new GeoLocation(-12, 12))
    )
    .Script(sc => sc
        .Type("number")
        .Ascending()
        .Script(script => script
            .Source("doc['numberOfCommits'].value * params.factor")
            .Params(p => p.Add("factor", 1.1))
        )
    )
)

Object Initializer syntax exampleedit

new SearchRequest<Project>
{
    Sort = new List<ISort>
    {
        new SortField { Field = "startedOn", Order = SortOrder.Ascending },
        new SortField { Field = "name", Order = SortOrder.Descending },
        new SortField { Field = "_score", Order = SortOrder.Descending },
        new SortField { Field = "_doc", Order = SortOrder.Ascending },
        new SortField
        {
            Field = Field<Project>(p => p.Tags.First().Added),
            Order = SortOrder.Descending,
            Missing = "_last",
            UnmappedType = FieldType.Date,
            Mode = SortMode.Average,
            NestedPath = Field<Project>(p => p.Tags),
            NestedFilter = new MatchAllQuery(),
        },
        new SortField
        {
            Field = Field<Project>(p => p.NumberOfCommits),
            Order = SortOrder.Descending,
            Missing = -1
        },
        new GeoDistanceSort
        {
            Field = "location",
            Order = SortOrder.Ascending,
            DistanceType = GeoDistanceType.Arc,
            GeoUnit = DistanceUnit.Centimeters,
            Mode = SortMode.Min,
            Points = new[] { new GeoLocation(70, -70), new GeoLocation(-12, 12) }
        },
        new ScriptSort
        {
            Type = "number",
            Order = SortOrder.Ascending,
            Script = new InlineScript("doc['numberOfCommits'].value * params.factor")
            {
                Params = new Dictionary<string, object>
                {
                    { "factor", 1.1 }
                }
            }
        }
    }
}

Example json output.  

{
  "sort": [
    {
      "startedOn": {
        "order": "asc"
      }
    },
    {
      "name": {
        "order": "desc"
      }
    },
    {
      "_score": {
        "order": "desc"
      }
    },
    {
      "_doc": {
        "order": "asc"
      }
    },
    {
      "tags.added": {
        "missing": "_last",
        "order": "desc",
        "mode": "avg",
        "nested_path": "tags",
        "nested_filter": {
          "match_all": {}
        },
        "unmapped_type": "date"
      }
    },
    {
      "numberOfCommits": {
        "missing": -1,
        "order": "desc"
      }
    },
    {
      "_geo_distance": {
        "location": [
          {
            "lat": 70.0,
            "lon": -70.0
          },
          {
            "lat": -12.0,
            "lon": 12.0
          }
        ],
        "order": "asc",
        "mode": "min",
        "distance_type": "arc",
        "unit": "cm"
      }
    },
    {
      "_script": {
        "order": "asc",
        "type": "number",
        "script": {
          "params": {
            "factor": 1.1
          },
          "source": "doc['numberOfCommits'].value * params.factor"
        }
      }
    }
  ]
}

Nested sort usageedit

In Elasticsearch 6.1.0+, using nested_path and nested_filter for sorting on fields mapped as nested types is deprecated. Instead, you should use the nested sort instead.

s => s
.Sort(ss => ss
    .Field(f => f
        .Field(p => p.Tags.First().Added)
        .Order(SortOrder.Descending)
        .MissingLast()
        .UnmappedType(FieldType.Date)
        .Mode(SortMode.Average)
        .Nested(n => n
            .Path(p => p.Tags)
            .Filter(ff => ff
                .MatchAll()
            )
        )
    )
)

Object Initializer syntax exampleedit

new SearchRequest<Project>
{
    Sort = new List<ISort>
    {
        new SortField
        {
            Field = Field<Project>(p => p.Tags.First().Added),
            Order = SortOrder.Descending,
            Missing = "_last",
            UnmappedType = FieldType.Date,
            Mode = SortMode.Average,
            Nested = new NestedSort
            {
                Path = Field<Project>(p => p.Tags),
                Filter = new MatchAllQuery()
            }
        }
    }
}

Example json output.  

{
  "sort": [
    {
      "tags.added": {
        "missing": "_last",
        "order": "desc",
        "mode": "avg",
        "nested": {
          "path": "tags",
          "filter": {
            "match_all": {}
          }
        },
        "unmapped_type": "date"
      }
    }
  ]
}

«  Sliced Scroll Search Usage     Source Filtering Usage  »