Erstellen Sie eine Elasticsearch-Curl-Abfrage für nicht null und nicht leer ("").

Wie kann ich eine Elasticsearch-Curl-Abfrage erstellen, um den Feldwert zu erhalten, der nicht null und nicht leer ist ("")?

Hier ist die MySQL-Abfrage:

select field1 from mytable where field1!=null and field1!="";

Ein Nullwert und eine leere Zeichenfolge führen dazu, dass kein Wert indiziert wird. In diesem Fall können Sie den existsFilter verwenden

curl -XGET 'http://127.0.0.1:9200/test/test/_search?pretty=1'  -d '
{
   "query" : {
      "constant_score" : {
         "filter" : {
            "exists" : {
               "field" : "myfield"
            }
         }
      }
   }
}
'

Oder in Kombination mit (zB) einer Volltextsuche auf dem titleFeld:

curl -XGET 'http://127.0.0.1:9200/test/test/_search?pretty=1'  -d '
{
   "query" : {
      "filtered" : {
         "filter" : {
            "exists" : {
               "field" : "myfield"
            }
         },
         "query" : {
            "match" : {
               "title" : "search keywords"
            }
         }
      }
   }
}
'

Wickeln Sie einen fehlenden Filter in den Abschnitt "Muss nicht" eines Bool-Filters ein . Es werden nur Dokumente zurückgegeben, in denen das Feld vorhanden ist. Wenn Sie die Eigenschaft "null_value" auf "true" setzen, sind Werte explizit nicht null.

{
  "query":{
     "filtered":{
        "query":{
           "match_all":{}
        },
        "filter":{
            "bool":{
              "must":{},
              "should":{},
              "must_not":{
                 "missing":{
                    "field":"field1",
                    "existence":true,
                    "null_value":true
                 }
              }
           }
        }
     }
  }
}

Wie @luqmaan in den Kommentaren hervorhob, heißt es in der Dokumentation , dass der Filter exists keine leeren Zeichenfolgen herausfiltert, da diese als Nicht-Null-Werte betrachtet werden .

Wenn Sie also zur Antwort von @ DrTech hinzufügen, um null und leere Zeichenfolgenwerte effektiv herauszufiltern, sollten Sie Folgendes verwenden:

{
    "query" : {
        "constant_score" : {
            "filter" : {
                "bool": {
                    "must": {"exists": {"field": "<your_field_name_here>"}},
                    "must_not": {"term": {"<your_field_name_here>": ""}}
                }
            }
        }
    }
}

In elasticsearch 5.6 muss ich den folgenden Befehl verwenden, um leere Zeichenfolgen herauszufiltern:

    GET /_search
    {
        "query" : {
            "regexp":{
                "<your_field_name_here>": ".+"
            }
        }
    }  

Sie können dies mit einer Bool-Abfrage und einer Kombination aus must und must_not wie folgt tun:

GET index/_search
{
    "query": {
        "bool": {
            "must": [
                {"exists": {"field": "field1"}}
            ],
            "must_not": [
                {"term": {"field1": ""}}
            ]
        }
    }
}

Ich habe dies mit Elasticsearch 5.6.5 in Kibana getestet.

Sie können nicht über fehlende Filter filtern .

"query": {
  "filtered": {
     "query": {
        "match_all": {}
     },
     "filter": {
        "not": {
           "filter": {
              "missing": {
                 "field": "searchField"
              }
           }
        }
     }
  }
}

Die einzige Lösung, die in 5.6.5 für mich funktioniert hat, war die Regex-Antwort von bigstone1998. Ich würde es jedoch aus Leistungsgründen vorziehen, keine Regex-Suche zu verwenden. Ich glaube, der Grund, warum die anderen Lösungen nicht funktionieren, ist, dass ein Standardfeld analysiert wird und daher kein leeres String-Token zum Negieren vorhanden ist. Die vorhandene Abfrage allein hilft auch nicht weiter, da eine leere Zeichenfolge als nicht null betrachtet wird.

Wenn Sie den Index nicht ändern können, ist der Regex-Ansatz möglicherweise Ihre einzige Option. Wenn Sie jedoch den Index ändern können, wird das Problem durch Hinzufügen eines Schlüsselwort-Unterfelds behoben.

In den Zuordnungen für den Index:

"myfield": {
    "type": "text",
    "fields": {
        "keyword": {
            "ignore_above": 256,
            "type": "keyword"
        }
    }
}

Dann können Sie einfach die Abfrage verwenden:

{
  "query": {
    "bool": {
      "must": {
        "exists": {
          "field": "myfield"
        }
      },
      "must_not": {
        "term": {
          "myfield.keyword": ""
        }
      }
    }
  }
}

Beachten Sie die .keywordKomponente must_not.

Wir verwenden Elasticsearch Version 1.6 und ich habe diese Abfrage eines Kollegen verwendet, um nicht null und nicht leer für ein Feld abzudecken:

{
  "query": {
    "filtered": {
      "query": {
        "match_all": {}
      },
      "filter": {
        "bool": {
          "must": [
            {
              "exists": {
                "field": "myfieldName"
              }
            },
            {
              "not": {
                "filter": {
                  "term": {
                    "myfieldName": ""
                  }
                }
              }
            }
          ]
        }
      }
    }
  }
}

Hier ist das Abfragebeispiel, um das Vorhandensein mehrerer Felder zu überprüfen:

{
  "query": {
    "bool": {
      "filter": [
        {
          "exists": {
            "field": "field_1"
          }
        },
        {
          "exists": {
            "field": "field_2"
          }
        },
        {
          "exists": {
            "field": "field_n"
          }
        }
      ]
    }
  }
}

Elastic search Get all record where condition not empty.

const searchQuery = {
      body: {
        query: {
          query_string: {
            default_field: '*.*',
            query: 'feildName: ?*',
          },
        },
      },
      index: 'IndexName'
    };

Sie können eine Bool-Kombinationsabfrage mit must / must_not verwenden, die eine hervorragende Leistung bietet und alle Datensätze zurückgibt, bei denen das Feld nicht null und nicht leer ist.

bool must_not ist wie "NOT AND", was Feld bedeutet! = "", bool muss existieren, bedeutet its! = null.

so effektiv aktivieren: wobei field1! = null und field1! = ""

GET  IndexName/IndexType/_search
{
    "query": {
        "bool": {
            "must": [{
                "bool": {
                    "must_not": [{
                        "term": { "YourFieldName": ""}
                    }]
                }
            }, {
                "bool": {
                    "must": [{
                      "exists" : { "field" : "YourFieldName" }
                    }]
                }
            }]
        }   
    }
}

ElasticSearch Version:

  "version": {
    "number": "5.6.10",
    "lucene_version": "6.6.1"
  }

Sie müssen die Bool-Abfrage mit must / must_not verwenden und sind vorhanden

Um herauszufinden, wo der Ort null ist

{
  "query": {
    "bool": {
      "must_not": {
        "exists": {
          "field": "place"
        }
      }
    }
  }
}

Um dorthin zu gelangen, ist der Ort nicht null

{
  "query": {
    "bool": {
      "must": {
        "exists": {
          "field": "place"
        }
      }
    }
  }
}