Come cercare una parte di una parola con ElasticSearch

Di recente ho iniziato a utilizzare ElasticSearch e non riesco a farlo cercare una parte di una parola.

Esempio: ho tre documenti del mio couchdb indicizzati in ElasticSearch:

{
  "_id" : "1",
  "name" : "John Doeman",
  "function" : "Janitor"
}
{
  "_id" : "2",
  "name" : "Jane Doewoman",
  "function" : "Teacher"
}
{
  "_id" : "3",
  "name" : "Jimmy Jackal",
  "function" : "Student"
} 

Quindi ora voglio cercare tutti i documenti contenenti "Doe"

curl http://localhost:9200/my_idx/my_type/_search?q=Doe

Ciò non restituisce alcun hit. Ma se lo cerco

curl http://localhost:9200/my_idx/my_type/_search?q=Doeman

Restituisce un documento (John Doeman).

Ho provato a impostare analizzatori e filtri diversi come proprietà del mio indice. Ho anche provato a utilizzare una query completa (ad esempio:

{
  "query": {
    "term": {
      "name": "Doe"
    }
  }
}

) Ma niente sembra funzionare.

Come posso fare in modo che ElasticSearch trovi John Doeman e Jane Doewoman quando cerco "Doe"?

AGGIORNARE

Ho provato a usare il tokenizer e il filtro nGram, come proposto da Igor, in questo modo:

{
  "index": {
    "index": "my_idx",
    "type": "my_type",
    "bulk_size": "100",
    "bulk_timeout": "10ms",
    "analysis": {
      "analyzer": {
        "my_analyzer": {
          "type": "custom",
          "tokenizer": "my_ngram_tokenizer",
          "filter": [
            "my_ngram_filter"
          ]
        }
      },
      "filter": {
        "my_ngram_filter": {
          "type": "nGram",
          "min_gram": 1,
          "max_gram": 1
        }
      },
      "tokenizer": {
        "my_ngram_tokenizer": {
          "type": "nGram",
          "min_gram": 1,
          "max_gram": 1
        }
      }
    }
  }
}

Il problema che sto riscontrando ora è che ogni singola query restituisce TUTTI i documenti. Qualche puntatore? La documentazione di ElasticSearch sull'uso di nGram non è eccezionale ...

Sto usando anche nGram. Uso tokenizer standard e nGram solo come filtro. Ecco la mia configurazione:

{
  "index": {
    "index": "my_idx",
    "type": "my_type",
    "analysis": {
      "index_analyzer": {
        "my_index_analyzer": {
          "type": "custom",
          "tokenizer": "standard",
          "filter": [
            "lowercase",
            "mynGram"
          ]
        }
      },
      "search_analyzer": {
        "my_search_analyzer": {
          "type": "custom",
          "tokenizer": "standard",
          "filter": [
            "standard",
            "lowercase",
            "mynGram"
          ]
        }
      },
      "filter": {
        "mynGram": {
          "type": "nGram",
          "min_gram": 2,
          "max_gram": 50
        }
      }
    }
  }
}

Troviamo parti di parole fino a 50 lettere. Regola il max_gram di cui hai bisogno. In tedesco le parole possono diventare davvero grandi, quindi ho impostato un valore elevato.

La ricerca con caratteri jolly iniziali e finali sarà estremamente lenta su un indice di grandi dimensioni. Se vuoi essere in grado di cercare per prefisso di parole, rimuovi i caratteri jolly iniziali. Se hai davvero bisogno di trovare una sottostringa nel mezzo di una parola, sarebbe meglio usare il tokenizer ngram.

Penso che non sia necessario modificare alcuna mappatura. Prova a usare query_string , è perfetto. Tutti gli scenari funzioneranno con l'analizzatore standard predefinito:

Abbiamo dati:

{"_id" : "1","name" : "John Doeman","function" : "Janitor"}
{"_id" : "2","name" : "Jane Doewoman","function" : "Teacher"}

Scenario 1:

{"query": {
    "query_string" : {"default_field" : "name", "query" : "*Doe*"}
} }

Risposta:

{"_id" : "1","name" : "John Doeman","function" : "Janitor"}
{"_id" : "2","name" : "Jane Doewoman","function" : "Teacher"}

Scenario 2:

{"query": {
    "query_string" : {"default_field" : "name", "query" : "*Jan*"}
} }

Risposta:

{"_id" : "1","name" : "John Doeman","function" : "Janitor"}

Scenario 3:

{"query": {
    "query_string" : {"default_field" : "name", "query" : "*oh* *oe*"}
} }

Risposta:

{"_id" : "1","name" : "John Doeman","function" : "Janitor"}
{"_id" : "2","name" : "Jane Doewoman","function" : "Teacher"}

EDIT - Stessa implementazione con ricerca elastica dei dati di primavera https://stackoverflow.com/a/43579948/2357869

Un'altra spiegazione di come query_string è meglio di altri https://stackoverflow.com/a/43321606/2357869

senza modificare i mapping dell'indice, è possibile eseguire una semplice query con prefisso che eseguirà ricerche parziali come si spera

vale a dire.

{
  "query": { 
    "prefix" : { "name" : "Doe" }
  }
}

https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-prefix-query.html

Prova la soluzione con è descritta qui: Ricerche di sottostring esatte in ElasticSearch

{
    "mappings": {
        "my_type": {
            "index_analyzer":"index_ngram",
            "search_analyzer":"search_ngram"
        }
    },
    "settings": {
        "analysis": {
            "filter": {
                "ngram_filter": {
                    "type": "ngram",
                    "min_gram": 3,
                    "max_gram": 8
                }
            },
            "analyzer": {
                "index_ngram": {
                    "type": "custom",
                    "tokenizer": "keyword",
                    "filter": [ "ngram_filter", "lowercase" ]
                },
                "search_ngram": {
                    "type": "custom",
                    "tokenizer": "keyword",
                    "filter": "lowercase"
                }
            }
        }
    }
}

Per risolvere il problema di utilizzo del disco e il termine di ricerca troppo lungo vengono utilizzati ngram lunghi di 8 caratteri (configurati con: "max_gram": 8 ). Per cercare termini con più di 8 caratteri, trasforma la tua ricerca in una query booleana AND alla ricerca di ogni sottostringa distinta di 8 caratteri in quella stringa. Ad esempio, se un utente cercasse un cantiere di grandi dimensioni (una stringa di 10 caratteri), la ricerca sarebbe:

"arge ya AND arge yar E rge yard .

Se si desidera implementare la funzionalità di completamento automatico, Completion Suggester è la soluzione più accurata. Il prossimo post sul blog contiene una descrizione molto chiara di come funziona.

In due parole, è una struttura di dati in memoria chiamata FST che contiene suggerimenti validi ed è ottimizzata per il recupero rapido e l'utilizzo della memoria. In sostanza, è solo un grafico. Per esempio, e FST contenente le parole hotel, marriot, mercure, munchene munichsarebbe simile a questa:

puoi usare regexp.

{ "_id" : "1", "name" : "John Doeman" , "function" : "Janitor"}
{ "_id" : "2", "name" : "Jane Doewoman","function" : "Teacher"  }
{ "_id" : "3", "name" : "Jimmy Jackal" ,"function" : "Student"  } 

se usi questa query:

{
  "query": {
    "regexp": {
      "name": "J.*"
    }
  }
}

ti verranno dati tutti i dati che il loro nome inizia con "J". Considera che vuoi ricevere solo i primi due record che il loro nome termina con "man" in modo da poter usare questa query:

{
  "query": { 
    "regexp": {
      "name": ".*man"
    }
  }
}

e se vuoi ricevere tutti i record che nel loro nome esistono "m", puoi usare questa query:

{
  "query": { 
    "regexp": {
      "name": ".*m.*"
    }
  }
}

Questo funziona per me. E spero che la mia risposta sia adatta a risolvere il tuo problema.

L'uso delle wilcard (*) impedisce il calcolo di un punteggio

Sto usando questo e ho lavorato

"query": {
        "query_string" : {
            "query" : "*test*",
            "fields" : ["field1","field2"],
            "analyze_wildcard" : true,
            "allow_leading_wildcard": true
        }
    }

Non importa.

Ho dovuto consultare la documentazione di Lucene. Sembra che io possa usare i caratteri jolly! :-)

curl http://localhost:9200/my_idx/my_type/_search?q=*Doe*

fa il trucco!