ElasticSearch : l'équivalent de l'opérateur dans ElasticSearch

Je suis en train d'essayer de trouver ElasticSearch requête équivalente à IN \ NOT en SQL.

Je sais que nous pouvons utiliser une chaîne de Requête requête avec plusieurs OU pour obtenir la même réponse, mais qui se termine avec beaucoup de OU de.

Quelqu'un peut-il partager l'exemple?

InformationsquelleAutor Sameer Deshmukh | 2015-05-07
  1. 77

    Similaire à ce que Chris a suggéré dans un commentaire, l'analogue de remplacement pour IN est le conditions filtre (requêtes impliquent de notation, ce qui peut améliorer la commande retournée).

    SELECT * FROM table WHERE id IN (1, 2, 3);

    L'équivalent Elasticsearch 1.x filtre serait:

    {
  "query" : {
    "filtered" : {
      "filter" : {
        "terms" : {
          "id" : [1, 2, 3]
        }
      }
    }
  }
}

    L'équivalent Elasticsearch 2.x+ filtre serait:

    {
  "query" : {
    "bool" : {
      "filter" : {
        "terms" : {
          "id" : [1, 2, 3]
        }
      }
    }
  }
}

    L'important, plats à emporter, c'est que le terms filtre (requête) à travailler sur des correspondances exactes. Il est implicitement une or opération, semblable à IN.

    Si vous voulais de l'inverser, vous pouvez utiliser le pas de filtre, mais je suggère d'avoir recours au un peu plus détaillé bool/must_not filtre (pour obtenir dans l'habitude de l'aide bool/must et bool).

    {
  "query" : {
    "bool" : {
      "must_not" : {
        "terms" : {
          "id" : [1, 2, 3]
        }
      }
    }
  }
}

    Dans l'ensemble, la bool composé de la syntaxe de la requête est l'un des plus importants de filtres dans Elasticsearch, comme le sont les term (singulier) et terms filtres (au pluriel, comme illustré).

    • quel sera le temps de la complexité pour la requête ci-dessus si la taille de la matrice est de 800 ou plus
    • qu'est-ce que les limites ici. toute taille maximale de la matrice?
    InformationsquelleAutor pickypg
  2. 0

    1 termes

    vous pouvez utiliser termes terme de la requête dans ElasticSearch qui agira comme DANS

    termes de la requête est utilisée pour vérifier si la valeur correspond à l'une des valeurs de Tableau.

    2 must_not

    must_not peut être utilisé comme PAS dans ElasticSearch.

    ex.

    GET my_index/my_type/_search
{
    "query" : {
         "bool" : {
              "must":[
                {
                   "terms": {
                        "id" : ["1234","12345","123456"]
                    }
                },
                {
                   "bool" : {
                        "must_not" : [
                            {
                              "match":{
                                  "id" : "123"
                               }
                            }
                        ]
                    }
                }
              ]
         }
    }
}
    1. existe

    Aussi, si cela vous aide, vous pouvez également utiliser "existe" requête pour vérifier si le champ existe ou pas.
    pour ex,
    vérifier si le champ existe

    "exists" : {
      "field" : "mobileNumber"
   }

    vérifier si un champ n'existe pas

    "bool":{
    "must_not" : [
        {
           "exists" : {
               "field" : "mobileNumber"
           }
        }
     ]
}
    InformationsquelleAutor niranjan harpale
  3. -1

    J'ai vu ce que vous avez demandé.
    Et j'ai écrit le code source ci-dessous.

    J'espère que cela vous aide à résoudre votre problème.

    requête sql :

    select * from tablename where fieldname in ('AA','BB');

    elastic search : 

    {
    query :{
        bool:{
            must:[{
              "script": {
                "script":{
                  "inline": "(doc['fieldname'].value.toString().substring(0,2).toUpperCase() in ['AA','BB']) == true"
                }
              }
            }],
            should:[],
            must_not:[]
        }
    }
}
    • La première: il y a des moyens plus faciles de faire une "startsWith" chaîne de style en ES et Java/Indolore pour cette question. Deuxièmement: ce n'est pas équivalente à la requête SQL. Ma réponse est toujours correct ici.
    InformationsquelleAutor sunnier