Elasticsearch - Order search results ASC

Question

having a problem with my elasticsearch.

Setup: Having a Company-Class with the data field "companyName". My search shall search and response all companys with the searched term.

If I try to sort via

.Sort(x=> x.OnField(x => x.CompanyName).Descending())

The data aren't sorted rightly - reference stackOverflow

I tried the given solution, but if I set my companyName to "not_analyzed" I cant even search anymore for the comnpany name or like a beginning "goo" (google) So I tried to set up a multifield mapping, with a suffix, which isn't analyzed and one which is analyzed.

My Index is set up like:

  client.CreateIndex(IndexName, c => c       
    .AddMapping<Exhibitor>(m =>m
        .MapFromAttributes()                        
        .Properties(o => o
        .MultiField(mf=>mf
            .Name(x=>x.CompanyName)             
            .Fields(fs => fs
                    .String(s=>s.Name(t=>t.CompanyName).Index(FieldIndexOption.Analyzed).Analyzer("standard"))
            .String(s=>s.Name(t=>t.CompanyName.Suffix("raw")).Index(FieldIndexOption.NotAnalyzed))))
        )

        )
    )
); 

My search looks like:

string SearchTerm ="my search term"
results = GetClient().Search<Company>(s => s 
    .Query(qa => qa 
       .MatchPhrasePrefix(m => m
       .OnField(f=>f.CompanyName)
      .Query(SearchTerm)
    ))

   .Sort(x => x.OnField(x => x.CompanyName.Suffix("raw")).Descending())

  .Size(maxResults).Skip(page * pageSize).Take(pageSize)

);

But that still doesn't work. Any ideas?

Thanks in advance.

Update 1:

For case insensitive sorting I added an custom analyzer:

var companyAnalyzer = new CustomAnalyzer
{
     Filter = new List<string> { "standard", "lowercase" },
      Tokenizer = "keyword"
};
client.CreateIndex(IndexName, c => c
       .Analysis(analysis => analysis
            .Analyzers(a => a
               .Add("companyanalyzer", companyAnalyzer)
             )
        )
         .AddMapping<Exhibitor>(m => m
              .MapFromAttributes()
              .Properties(o => o
                  .MultiField(mf => mf
                     .Name(x => x.CompanyName)
                         .Fields(fs => fs
                               .String(s => s.Name(t => t.CompanyName).Index(FieldIndexOption.Analyzed).Analyzer("standard"))
                               .String(s => s.Name(t => t.CompanyName.Suffix("raw")).Index(FieldIndexOption.Analyzed).Analyzer("companyanalyzer"))))
                 )

          )
 );

Answer 1

This example is working, maybe it will put some light on your issue.

var indicesResponse = client.DeleteIndex(descriptor => descriptor.Index(indexName));

client.CreateIndex(indexName, c => c
    .AddMapping<Exhibitor>(m => m
        .MapFromAttributes()
        .Properties(o => o
            .MultiField(mf => mf
                .Name(x => x.CompanyName)
                .Fields(fs => fs
                    .String(s => s.Name(t => t.CompanyName).Index(FieldIndexOption.Analyzed).Analyzer("standard"))
                    .String(s => s.Name(t => t.CompanyName.Suffix("raw")).Index(FieldIndexOption.NotAnalyzed))))
        )));


client.Index(new Exhibitor { Id = 1, CompanyName = "a test" });
client.Index(new Exhibitor { Id = 2, CompanyName = "b test" });
client.Index(new Exhibitor { Id = 3, CompanyName = "c test" }); 

client.Refresh();

string SearchTerm = "test";
var results = client.Search<Exhibitor>(s => s
    .Query(qa => qa
        .MatchPhrasePrefix(m => m
            .OnField(f => f.CompanyName)
            .Query(SearchTerm)
        ))
    .Sort(x => x.OnField(f => f.CompanyName.Suffix("raw")).Descending())
    );

Result of this query:

{
   "took": 2,
   "timed_out": false,
   "_shards": {..}
   "hits": {
      "total": 3,
      "max_score": null,
      "hits": [
         {
            "_index": "my_index",
            "_type": "exhibitor",
            "_id": "3",
            "_score": null,
            "_source": {
               "id": 3,
               "companyName": "c test"
            },
            "sort": [
               "c test"
            ]
         },
         {
            "_index": "my_index",
            "_type": "exhibitor",
            "_id": "2",
            "_score": null,
            "_source": {
               "id": 2,
               "companyName": "b test"
            },
            "sort": [
               "b test"
            ]
         },
         {
            "_index": "my_index",
            "_type": "exhibitor",
            "_id": "1",
            "_score": null,
            "_source": {
               "id": 1,
               "companyName": "a test"
            },
            "sort": [
               "a test"
            ]
         }
      ]
   }
}

Index mapping:

{
    "my_index" : {
        "mappings" : {
            "exhibitor" : {
                "properties" : {
                    "companyName" : {
                        "type" : "string",
                        "analyzer" : "standard",
                        "fields" : {
                            "raw" : {
                                "type" : "string",
                                "index" : "not_analyzed"
                            }
                        }
                    },
                    "id" : {
                        "type" : "integer"
                    }
                }
            }
        }
    }
}

Hope it helps.