consultas - Cliente Elasticsearch NEST que crea campos de campo múltiple con finalización

elasticsearch nest filter

Question

Estoy tratando de crear algunos sugerentes de finalización en algunos de mis campos. Mi clase de documento se ve así:

[ElasticType(Name = "rawfiles", IdProperty = "guid")]
public class RAW
{
    [ElasticProperty(OmitNorms = true, Index = FieldIndexOption.NotAnalyzed, Type = FieldType.String, Store = true)]
    public string guid { get; set; }

    [ElasticProperty(OmitNorms = true, Index = FieldIndexOption.Analyzed, Type = FieldType.String, Store = true, IndexAnalyzer = "def_analyzer", SearchAnalyzer = "def_analyzer_search", AddSortField = true)]
    public string filename { get; set; }

    [ElasticProperty(OmitNorms = true, Index = FieldIndexOption.Analyzed, Type = FieldType.String, Store = true, IndexAnalyzer = "def_analyzer", SearchAnalyzer = "def_analyzer_search")]
    public List<string> tags { get { return new List<string>(); } }
}

Y aquí es cómo estoy tratando de crear los campos de finalización

public bool CreateMapping(ElasticClient client, string indexName)
{
    IIndicesResponse result = null;
    try
    {
        result = client.Map<RAW>(
                c => c.Index(indexName)
                    .MapFromAttributes()
                    .AllField(f => f.Enabled(false))
                    .SourceField(s => s.Enabled())
                    .Properties(p => p
                        .Completion(s => s.Name(n => n.tags.Suffix("comp"))
                                    .IndexAnalyzer("standard")
                                    .SearchAnalyzer("standard")
                                    .MaxInputLength(20)
                                    .Payloads()
                                    .PreservePositionIncrements()
                                    .PreserveSeparators())
                        .Completion(s2 => s2.Name(n=>n.filename.Suffix("comp"))
                                    .IndexAnalyzer("standard")
                                    .SearchAnalyzer("standard")
                                    .MaxInputLength(20)
                                    .Payloads()
                                    .PreservePositionIncrements()
                                    .PreserveSeparators())
                        )
                   );
    }
    catch (Exception)
    {

    }

    return result != null && result.Acknowledged;
}

Mi problema es que esto solo está creando un único campo de finalización llamado "comp". Tenía la impresión de que esto crearía dos campos de finalización, uno llamado nombredearchivo.comp y otro llamado tags.comp.

Luego probé la respuesta a esta pregunta de SO, pero esto complicaba el asunto aún peor ya que ahora mis dos campos fueron mapeados como un campo de finalización solamente.

Para que quede claro, quiero crear un campo múltiple (campo) que tenga un archivo de datos, clasificación y compleción. Al igual que el de este ejemplo

Answer 1

Así es como puedes reproducir un ejemplo de autocompletado de tu artículo adjunto.

Mi clase simple (vamos a implementar autocompletar en la propiedad Name )

public class Document
{
    public int Id { get; set; }
    public string Name { get; set; }
}

Para crear una asignación de campo múltiple en NEST, debemos definir la asignación de esta manera:

var indicesOperationResponse = client.CreateIndex(descriptor => descriptor
    .Index(indexName)
    .AddMapping<Document>(m => m
        .Properties(p => p.MultiField(mf => mf
            .Name(n => n.Name)
            .Fields(f => f
                .String(s => s.Name(n => n.Name).Index(FieldIndexOption.Analyzed))
                .String(s => s.Name(n => n.Name.Suffix("sortable")).Index(FieldIndexOption.NotAnalyzed))
                .String(s => s.Name(n => n.Name.Suffix("autocomplete")).IndexAnalyzer("shingle_analyzer"))))))
    .Analysis(a => a
        .Analyzers(b => b.Add("shingle_analyzer", new CustomAnalyzer
        {
            Tokenizer = "standard",
            Filter = new List<string> {"lowercase", "shingle_filter"}
        }))
        .TokenFilters(b => b.Add("shingle_filter", new ShingleTokenFilter
        {
            MinShingleSize = 2,
            MaxShingleSize = 5
        }))));

Vamos a indexar algunos documentos:

client.Index(new Document {Id = 1, Name = "Tremors"});
client.Index(new Document { Id = 2, Name = "Tremors 2: Aftershocks" });
client.Index(new Document { Id = 3, Name = "Tremors 3: Back to Perfection" });
client.Index(new Document { Id = 4, Name = "Tremors 4: The Legend Begins" });
client.Index(new Document { Id = 5, Name = "True Blood" });
client.Index(new Document { Id = 6, Name = "Tron" });
client.Index(new Document { Id = 7, Name = "True Grit" });
client.Index(new Document { Id = 8, Name = "Land Before Time" });
client.Index(new Document { Id = 9, Name = "The Shining" });
client.Index(new Document { Id = 10, Name = "Good Burger" });

client.Refresh();

Ahora, estamos listos para escribir la consulta de prefijo :)

var searchResponse = client.Search<Document>(s => s
    .Query(q => q
        .Prefix("name.autocomplete", "tr"))
    .SortAscending(sort => sort.Name.Suffix("sortable")));

Esta consulta nos conseguirá

Tremors 2: Aftershocks
Tremors 3: Back to Perfection
Tremors 4: The Legend Begins
Tron
True Blood
True Grit

Espero que esto te ayudará.

Recientemente, chicos de NEST prepararon un gran tutorial sobre NEST y elasticsearch. Hay una parte sobre sugerencias , debería ser realmente útil para usted.