SearchRequest Lors de la traduction de l'anglais de référence

SearchRequest est utilisé pour les opérations qui recherchent des documents, des agrégats et des suggestions, et fournit également un moyen de demander la mise en évidence du document résultant.

Cela dit, mais je pense que c'est comme un chef-d'œuvre pour envoyer des requêtes à Elasticsearch à l'aide de l'API.

java

SearchRequest searchRequest = new SearchRequest();

Référence: https://www.elastic.co/guide/en/elasticsearch/client/java-rest/master/java-rest-high-search.html

SearchSourceBuilder SearchSourceBuilder sert à ajouter des paramètres de recherche.

java

SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();

Référence: https://www.elastic.co/guide/en/elasticsearch/client/java-rest/master/java-rest-high-search.html

RestHighLevelClient RestHighLevelClient est le client REST recommandé pour remplacer le TransportClient précédemment utilisé. En l'utilisant, vous pouvez accéder à Elasticsearch à partir d'une application Java via http.

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);

Référence: https://www.elastic.co/guide/en/elasticsearch/client/java-rest/current/_basic_authentication.html

function score query Dans la requête de score de fonction, plusieurs conditions (fonctions) peuvent être décrites dans la section des fonctions, et le tri est effectué en utilisant la valeur totale des scores pour chaque condition.

Juste un exemple

FunctionScoreQueryBuilder functionScoreQueryBuilder = null;
ArrayList<FunctionScoreQueryBuilder.FilterFunctionBuilder> functionScoreArrayList = new ArrayList<>();
//Vous pouvez en ajouter plusieurs
filterFunctionList.add(
    new FunctionScoreQueryBuilder.FilterFunctionBuilder(QueryBuilders.termQuery("FashionItemId", "1"),
        ScoreFunctionBuilders.fieldValueFactorFunction("custom_score.").factor(Float.valueOf("0.0254389"
)).missing(0.2)));
//ArrayList de type à FunctionScoreQueryBuilder.FilterFunctionBuilder[]À
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);

• Fonction ScoreQuery Builder a quelques articles qui sont vraiment utiles ...

Référence: https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-function-score-query.html

count Il peut être spécifié comme «.count» pour RestHighLevelClient.

java

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

Ensuite, vous pouvez obtenir le nombre de résultats dans searchRequest sous la forme de CountResponse.

Référence: https://www.elastic.co/guide/en/elasticsearch/reference/current/search-count.html

search Il peut être spécifié avec .search pour RestHighLevelClient.

java

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

Ensuite, vous pouvez obtenir les résultats de la recherche qui frappent searchRequest sous la forme SearchResponse.

Référence: https://www.elastic.co/guide/en/elasticsearch/reference/current/search-search.html

_source «_Source» d'Elasticsearch est comme une clause SELECT dans SQL. Dans le cas de l'API, spécifiez le champ à récupérer à l'aide de fetchSource. En réduisant les champs à acquérir, la quantité de données peut être réduite, de sorte qu'une amélioration de la vitesse peut être attendue. Spécifiez le champ à acquérir dans le premier argument et le champ à exclure dans le deuxième argument. Dans le cas du comptage mentionné ci-dessus, c'est correct sans préciser.

java

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

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

Sort C'est Order By en SQL. Utilisez FieldSortBuilder pour spécifier le tri.

Lors du tri sur plusieurs colonnes

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

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

from & size Cela correspond au décalage et à la limite en SQL. Vous pouvez le spécifier avec .from`` .to pour SearchSourceBuilder mentionné ci-dessus.

java

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

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

BoolQuery Utilisé pour combiner d'autres requêtes. Vous pouvez combiner AND, OR, NOT. Il existe quatre types de BoolQuery.

Requête de recherche typique

termQuery Si cela correspond. En SQL = (égal) Référence: https://www.elastic.co/guide/en/elasticsearch/reference/7.8/query-dsl-term-query.html

temrsQuery Y a-t-il un match? Clause IN dans SQL Référence: https://www.elastic.co/guide/en/elasticsearch/client/java-api/current/java-term-level-queries.html#java-query-dsl-terms-query

rangeQuery Y a-t-il une plage spécifiée? > =, <=, <,> Dans SQL Référence: https://www.elastic.co/guide/en/elasticsearch/client/java-api/current/java-term-level-queries.html#java-query-dsl-range-query

Exemple (SQL vs ElasticSearch vs Java)

Pour 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)
    )
)

Pour 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
                            ]
                          }
                        }
                    ]
                  }
                }
              ]
            }
          }
        ]
      }
    }
  ]
}

(C'est très compliqué et difficile à voir ...)

Pour 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);

Méthode de vérification

Vous pouvez obtenir des requêtes Elasticsearch en effectuant toString () vers BoolQueryBuilder. Vérifiez si la requête est correcte en comparant le résultat avec la requête attendue ou en la frappant avec Kibana.

Exemple (SQL vs ElasticSearch vs Java) Lors de la validation des requêtes BoolQueryBuilder

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

finalement

Cet article n'est que l'information au moment où je l'ai touché pour la première fois. À cette époque, il y avait peu d'articles, mais de nos jours, si vous recherchez, il peut y avoir beaucoup de bons articles. J'espère que cela sera utile pour ceux qui découvrent l'API Elasticsearch.