ES: ricerca elastica

Prerequisiti

Ricerca elastica: guida completa

Nei nostri precedenti articoli su Elastic Search, abbiamo impostato un client ES e documenti indicizzati. Ora utilizzeremo quel client per eseguire varie operazioni come la ricerca, l'ordinamento, l'impaginazione e il filtraggio sui nostri documenti indicizzati. Imparando a utilizzare queste funzionalità, possiamo ottimizzare ulteriormente le capacità di ricerca e analisi di Elastic Search nei nostri progetti. Immergiamoci e vediamo come funzionano queste funzioni in azione.

Metodo di ricerca

Ciò restituisce risultati di ricerca che corrispondono alla query definita nella richiesta.

async search({
  q: { query, sort },
  pageSize = 10,
  offset = 0,
  index,
  scroll,
}: EsSearchBody) {
  try {
    return this.client.search({
      index,
      sort,
      query: query,
      scroll,
      from: offset,
      size: pageSize
      });
  } catch (err) {
    throw err;
  }
}

Dopo aver eseguito la query sopra, otterremo una risposta simile a questa:

{
  "took" : 571,
  "timed_out" : false,
  "_shards" : {
    "total" : 3,
    "successful" : 3,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {
    "total" : {
      "value" : 2,
      "relation" : "eq"
    },
    "max_score" : 1.0,
    "hits" : [
      {
        "_index" : "quotes",
        "_type" : "_doc",
        "_id" : "PZkvy3ABKNkWakGIzsCc",
        "_score" : 1.0,
        "_source" : {
          "author" : "Farrah Gray",
          "content" : "Build your own dreams, or someone else will hire you to build theirs.",
          "year" : 1984
        }
      },
      {
        "_index" : "quotes",
        "_type" : "_doc",
        "_id" : "QZkwy3ABKNkWakGIbMDh",
        "_score" : 1.0,
        "_source" : {
          "author" : "Abraham Lincoln",
          "content" : "It’s not the years in your life that count. It’s the life in your year.",
          "year" : 1809
        }
      },
      {
        "_index" : "quotes",
        "_type" : "_doc",
        "_id" : "Bwb72XABdLCfAS5iYiHx",
        "_score" : 1.0,
        "_source" : {
          "author" : "Albert Einstein",
          "content" : "Strive not to be a success, but rather to be of value.",
          "year" : 1881
        }
      }
    ]
  }
}

1. _shardsproperty : questo mostra quanti frammenti sono stati scansionati per i nostri dati, quanti hanno avuto successo, saltati e falliti.
2. hitsoggetto : possiamo vedere informazioni su un numero di risultati e quanto è accurato il conteggio.
3. max_scoreil valore più alto del punteggio dai risultati. In questa query, è uguale a 1.0ma in una query diversa, anche questo valore può essere diverso.

Ecco un esempio di come recuperare tutti i documenti indicizzati in un indice ES. Per questo dobbiamo usare match_allquery.

this.client.search({
  index: 'test_index',
  query: {
    match_all: {}
  }
})

supponiamo di voler mostrare solo i risultati contenenti la parola “successo”. Ora invece di match_all, dobbiamo usare la mustclausola. La query finale apparirà come sotto

this.client.search({
  index: 'test_index',
  query: {
    match: {
      content: "success"
    }
  }
})

Visualizziamo solo gli autori di citazioni precedenti al 1900 e che includono la parola successo.

this.client.search({
  index: "test_index",
  query: {
    bool: {
      must: [
        {
          range: {
            year: {
              lte: 1900
            }
          }
        },
        {
          match: {
            content: "success"
          }
        }
      ]
    }
  },
  _source: "author"
})

1. Il queryparametro indica il contesto della query.
2. Le clausole bool, e mustvengono utilizzate nel contesto della query, il che significa che vengono utilizzate per valutare quanto ogni documento corrisponde alla query.rangematch
3. Nella range query, specifichiamo che stiamo cercando documenti antecedenti o inclusi nel 1900.
4. Nella matchquery, indichiamo che il risultato dovrebbe includere la parola "successo"
5. In _sourceproperty, abbiamo definito quale campo deve restituire la query. Qui possiamo passare un campo come una stringa o un array di campi.

(...)
"hits" : [
      {
        "_index" : "quotes",
        "_type" : "_doc",
        "_id" : "Bwb72XABdLCfAS5iYiHx",
        "_score" : 2.0226655,
        "_source" : {
          "author" : "Albert Einstein"
        }
      },
      {
        "_index" : "quotes",
        "_type" : "_doc",
        "_id" : "CAb72XABdLCfAS5i7SGR",
        "_score" : 1.6451601,
        "_source" : {
          "author" : "Florence Nightingale"
        }
      }
    ]
(...)

Nei risultati della query sopra, puoi vedere che ogni risultato ha una propria _scoreproprietà. Ha definito la pertinenza del documento, quanto bene un documento corrisponde a una query. Più alto è il valore del punteggio, più rilevante è il documento. Ogni tipo di query avrebbe un calcolo del punteggio diverso in base al contesto della query e del filtro.

Qui stiamo cercando i documenti più rilevanti per una frase: "non avere successo".

this.client.search({
  index: "test_index",
  query: {
    bool: {
      must: [
        {
          match: {
            content: "not to be a success"
          }
        },
      ]
    }
  },
})

Maggiore è il punteggio, più accurato è il documento.

Impaginazione

Quando abbiamo una funzione, in cui dobbiamo visualizzare un'enorme quantità di dati, allora abbiamo bisogno del meccanismo di impaginazione. In ES è abbastanza semplice. Dobbiamo usare due proprietà:

• from: specifica da quale record nell'indice Elasticsearch dovrebbe iniziare la ricerca
• size: definisce quanti risultati devono essere restituiti.

this.client.search({
  index: 'test_index',
  query: {
    match_all: {}
  },
  from: 0,
  size: 10,
})

A volte, tuttavia, non disponiamo di un punteggio di pertinenza significativo o desideriamo ordinare in base a proprietà diverse dopo aver ottenuto risultati di ricerca pertinenti.

this.client.search({
  index: 'test_index',
  query: {
    match_all: {}
  },
  sort: {
    createdAt: { order: 'asc' }
  }
  from: 0,
  size: 10,
})

Filtraggio

In tutti gli esempi precedenti, abbiamo visto come funziona il contesto della query, quanto bene un documento corrisponde alla clausola della query.

In un contesto di filtro, otteniamo una risposta sì/no a: "Questo documento corrisponde a una domanda di query?"

Per trovare la citazione creata da Albert Einstein tra il 1800 e il 1900, possiamo utilizzare la seguente query filtrata:

this.client.search({
  index: 'test_index',
  query: {
    bool: {
      filter: [
        {
          match: { author: "Albert" }
        },
        { range: 
          {
            year:  {
              gte: 1800,
              lte: 1900
            }
          }
        }
      ]
    }
  },
  from: 0,
  size: 10,
})

"max_score" : 0.0,
"hits" : [
  {
    "_index" : "quotes",
    "_type" : "_doc",
    "_id" : "Bwb72XABdLCfAS5iYiHx",
    "_score" : 0.0,
    "_source" : {
      "author" : "Albert Einstein",
      "content" : "Strive not to be a success, but rather to be of value.",
      "year" : 1881
    }
  }
]

Riferimenti

Client JavaScript Elasticsearch [8.5] ​​| Elastico

Riferimento API | Client JavaScript Elasticsearch [8.5] ​​| Elastico

Esempi | Client JavaScript Elasticsearch [8.5] ​​| Elastico

Spero ti sia piaciuto leggere su Elastic Search e su come può essere utilizzato per ottimizzare la ricerca e l'analisi in varie applicazioni. Se hai trovato utile questo articolo o hai ulteriori domande, non esitare a contattarmi tramite i commenti.

Per ulteriori aggiornamenti e approfondimenti sulle ultime tendenze tecnologiche, assicurati di seguirmi su Twitter o LinkedIn . Grazie per aver letto e non vedo l'ora di connettermi con voi sui social media.

Cinguettio :https://twitter.com/geekfarmer_

LinkedIn :https://www.linkedin.com/in/geekfarmer