SearchRequest Bei der Übersetzung der Referenz Englisch

SearchRequest wird für Vorgänge verwendet, die nach Dokumenten, Aggregaten und Vorschlägen suchen, und bietet auch die Möglichkeit, das Hervorheben des resultierenden Dokuments anzufordern.

Es heißt, aber ich denke, es ist wie ein Meisterwerk für das Senden von Anfragen an Elasticsearch über die API.

java

SearchRequest searchRequest = new SearchRequest();

Referenz: https://www.elastic.co/guide/en/elasticsearch/client/java-rest/master/java-rest-high-search.html

SearchSourceBuilder SearchSourceBuilder dient zum Hinzufügen von Suchparametern.

java

SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();

Referenz: https://www.elastic.co/guide/en/elasticsearch/client/java-rest/master/java-rest-high-search.html

RestHighLevelClient RestHighLevelClient ist der empfohlene REST-Client, um den zuvor verwendeten TransportClient zu ersetzen. Mit dieser Funktion können Sie über eine Java-App über http auf Elasticsearch zugreifen.

java

final CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
credentialsProvider.setCredentials(AuthScope.ANY,
    new UsernamePasswordCredentials("user", "password")
);

RestHighLevelClient client = new RestHighLevelClient(
    RestClient.builder(new HttpHost("localhost", 9200, "https"))
        .setHttpClientConfigCallback(httpAsyncClientBuilder -> httpAsyncClientBuilder
          .setDefaultCredentialsProvider(credentialsProvider))
);

searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);

Referenz: https://www.elastic.co/guide/en/elasticsearch/client/java-rest/current/_basic_authentication.html

function score query Bei der Abfrage von Funktionsbewertungen können im Funktionsabschnitt mehrere Bedingungen (Funktionen) beschrieben werden, und die Sortierung wird anhand der Summe der Bewertungen für jede Bedingung durchgeführt.

Nur ein Beispiel

FunctionScoreQueryBuilder functionScoreQueryBuilder = null;
ArrayList<FunctionScoreQueryBuilder.FilterFunctionBuilder> functionScoreArrayList = new ArrayList<>();
//Sie können mehrere hinzufügen
filterFunctionList.add(
    new FunctionScoreQueryBuilder.FilterFunctionBuilder(QueryBuilders.termQuery("FashionItemId", "1"),
        ScoreFunctionBuilders.fieldValueFactorFunction("custom_score.").factor(Float.valueOf("0.0254389"
)).missing(0.2)));
//ArrayList-Typ in FunctionScoreQueryBuilder.FilterFunctionBuilder[]Zu
FunctionScoreQueryBuilder.FilterFunctionBuilder[] functions = functionScoreArrayList.toArray(new FunctionScoreQueryBuilder.FilterFunctionBuilder[functionScoreArrayList.size()]);
functionScoreQueryBuilder = new FunctionScoreQueryBuilder(queryBuilder, functions).scoreMode(FunctionScoreQuery.ScoreMode.SUM).boostMode(CombineFunction.REPLACE);
searchSourceBuilder.query(functionScoreQueryBuilder);

• Funktion ScoreQuery Builder enthält nur wenige Artikel, die wirklich hilfreich sind ...

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

count Es kann als ".count" für RestHighLevelClient angegeben werden.

java

CountResponse countResponse = null;
countResponse = restHighLevelClient.count(searchRequest, RequestOptions.DEFAULT);

Anschließend können Sie die Anzahl der Treffer in searchRequest in Form von CountResponse abrufen.

Referenz: https://www.elastic.co/guide/en/elasticsearch/reference/current/search-count.html

search Es kann mit .search für RestHighLevelClient angegeben werden.

java

SearchResponse searchResponse = null;
searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);

Anschließend können Sie die Suchergebnisse, die auf searchRequest klicken, in Form von SearchResponse abrufen.

Referenz: https://www.elastic.co/guide/en/elasticsearch/reference/current/search-search.html

_source Die "_source" von Elasticsearch ähnelt einer SELECT-Klausel in SQL. Geben Sie im Fall der API das Feld an, das mit fetchSource abgerufen werden soll. Durch Eingrenzen der zu erfassenden Felder kann die Datenmenge reduziert werden, sodass eine Geschwindigkeitsverbesserung erwartet werden kann. Geben Sie das Feld an, das im ersten Argument erfasst werden soll, und das Feld, das im zweiten Argument ausgeschlossen werden soll. Im Fall der oben erwähnten Zählung ist es in Ordnung, ohne anzugeben.

java

searchSourceBuilder.fetchSource(new String[]{"FashionItemId", "ItemPrice", "FashionItemSize",
    "FashionItemLargeCategory", "FashionItemSmallCategory"},
    "ExclusionFashionItemId");

Referenz: https://www.elastic.co/guide/en/elasticsearch/client/java-rest/current/java-rest-high-search.html#_source_filtering

Sort Es ist Order By in SQL. Verwenden Sie FieldSortBuilder, um die Sortierung anzugeben.

Beim Sortieren nach mehreren Spalten

return searchSourceBuilder.sort(new FieldSortBuilder("ItemPrice").order(SortOrder.ASC))
    .sort(new FieldSortBuilder("FashionItemId").order(SortOrder.DESC))
    .sort(new FieldSortBuilder("StartDatetime").order(SortOrder.DESC));

Referenz: https://www.elastic.co/guide/en/elasticsearch/client/java-rest/current/java-rest-high-search.html#_specifying_sorting

from & size Dies entspricht Offset & Limit in SQL. Sie können es mit .from`` .to für den oben genannten SearchSourceBuilder angeben.

java

SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
searchSourceBuilder.from(0);
searchSourceBuilder.size(100);

Referenz: https://www.elastic.co/guide/en/elasticsearch/client/java-rest/master/java-rest-high-search.html#_using_the_searchsourcebuilder

BoolQuery Wird verwendet, um andere Abfragen zu kombinieren. Sie können UND ODER ODER NICHT kombinieren. Es gibt vier Arten von BoolQuery.

Typische Suchabfrage

termQuery Ob es passt. In SQL = (gleich) Referenz: https://www.elastic.co/guide/en/elasticsearch/reference/7.8/query-dsl-term-query.html

temrsQuery Gibt es ein Streichholz? IN-Klausel in SQL Referenz: https://www.elastic.co/guide/en/elasticsearch/client/java-api/current/java-term-level-queries.html#java-query-dsl-terms-query

rangeQuery Gibt es einen bestimmten Bereich? > =, <=, <,> In SQL Referenz: https://www.elastic.co/guide/en/elasticsearch/client/java-api/current/java-term-level-queries.html#java-query-dsl-range-query

Beispiel (SQL vs ElasticSearch vs Java)

Für SQL

AND StartDatetime >= '2019-12-06 17:33:18'
AND (
    (
        FashionItemLargeCategory <> 1
        AND FashionItemSmallCategory NOT IN (10,20,30)
        AND FashionItemSize IN (1,2)
    ) OR (
        (
            FashionItemLargeCategory = 2
            OR FashionItemSmallCategory  IN (40,50,60)
        )
        AND FashionItemSize  IN (9,10)
    )
)

Für Elasticsearch

"bool": {
  "filter": [
    {
      "range": {
        "StartDatetime": {
          "from": null,
          "to": "2019-12-06 17:33:18",
          "include_lower": true,
          "include_upper": false
        }
      }
    },
    {
      "bool": {
        "filter": [
          {
            "bool": {
              "should": [
                {
                  "bool": {
                    "filter": [
                      {
                        "terms": {
                          "FashionItemSize ": [
                            1,
                            2
                          ]
                        }
                      }
                    ],
                    "must_not": [
                      {
                        "term": {
                          "FashionItemLargeCategory ": {
                            "value": 1,
                            "boost": 1
                          }
                        }
                      },
                      {
                        "terms": {
                          "FashionItemSmallCategory ": [
                            10,
                            20,
                            30
                          ]
                        }
                      }
                    ]
                  }
                },
                {
                  "bool": {
                    "filter": [
                      {
                        "terms": {
                          "FashionItemSize": [
                            9,
                            10
                          ]
                        }
                      }
                    ],
                    "should": [
                        {
                          "term": {
                            "FashionItemLargeCategory ": {
                              "value": 1
                            }
                          }
                        },
                        {
                          "terms": {
                            "FashionItemSmallCategory  ": [
                              40,
                              50,
                              60
                            ]
                          }
                        }
                    ]
                  }
                }
              ]
            }
          }
        ]
      }
    }
  ]
}

(Es ist sehr kompliziert und schwer zu sehen ...)

Für Java

integer[] smallCategories1 = {10, 20, 30};
integer[] itemSize1 = {1, 2};
integer[] smallCategories2 = {40, 50, 60};
integer[] itemSize2 = {9, 10};

BoolQueryBuilder qb1 = boolQuery()
    .mustNot(termQuery("FashionItemLargeCategory", 1))
    .mustNot(termsQuery("FashionItemSmallCategory", smallCategories1))
    .filter(termsQuery("FashionItemSize" , itemSize1));

BoolQueryBuilder qb2 = boolQuery()
    .should(termQuery("FashionItemLargeCategory", 2))
    .should(termsQuery("FashionItemSmallCategory", smallCategories2))
    .filter(termsQuery("FashionItemSize", itemSize2));

BoolQueryBuilder qb3 = boolQuery()
    .should(qb1)
    .should(qb2);

BoolQueryBuilder qb4 = boolQuery()
    .filter(rangeQuery("StartDatetime").from(null).lt("2019-12-06 17:33:18"))
    .filter(qb3);

Überprüfungsmethode

Sie können Elasticsearch-Abfragen abrufen, indem Sie toString () für BoolQueryBuilder ausführen. Überprüfen Sie, ob die Abfrage korrekt ist, indem Sie das Ergebnis mit der erwarteten Abfrage vergleichen oder mit Kibana treffen.

Beispiel (SQL vs ElasticSearch vs Java) Beim Überprüfen von BoolQueryBuilder-Abfragen

System.out.println(qb4.toString());

Schließlich

Dieser Artikel ist nur die Information zu der Zeit, als ich ihn zum ersten Mal berührte. Zu dieser Zeit gab es nur wenige Artikel, aber heutzutage gibt es viele gute Artikel, wenn Sie nachschlagen. Ich hoffe, es ist hilfreich für diejenigen, die neu in der Elasticsearch-API sind.