Multi-Feld, multi-word -, Spiel ohne query_string

Ich würde gerne in der Lage, mit einer multi-word-Suche mit mehreren Feldern, wo jedes Wort, das gesucht ist enthalten in alle der Felder, beliebige Kombination. Der Haken ist, ich möchte vermeiden Sie die Verwendung query_string.

curl -X POST "http://localhost:9200/index/document/1" -d '{"id":1,"firstname":"john","middlename":"clark","lastname":"smith"}'
curl -X POST "http://localhost:9200/index/document/2" -d '{"id":2,"firstname":"john","middlename":"paladini","lastname":"miranda"}'

Ich würde gerne die Suche für 'John Smith', um auf übereinstimmung nur Dokument 1. Die folgende Abfrage funktioniert, was ich brauche, aber ich hätte es lieber vermeiden, mit query_string im Fall übergibt der Benutzer "ODER", "UND" und die anderen advanced params.

curl -X GET 'http://localhost:9200/index/_search?per_page=10&pretty' -d '{
  "query": {
    "query_string": {
      "query": "john smith",
      "default_operator": "AND",
      "fields": [
        "firstname",
        "lastname",
        "middlename"
      ]
    }
  }
}'

Ich komme immer auf diese Frage immer und immer und immer wieder. Große, immergrüne Frage!

InformationsquelleAutor brupm | 2013-03-15

Was Sie suchen, ist die multi-match query, aber es nicht ganz so, wie Sie möchten.

Vergleichen Sie die Ausgabe von überprüfen für multi_match vs query_string.

multi_match (mit Betreiber and) wird sicherstellen, dass ALLE Bedingungen vorhanden sind, die in mindestens einem Feld:

curl -XGET 'http://127.0.0.1:9200/_validate/query?pretty=1&explain=true'  -d '
{
   "multi_match" : {
      "operator" : "and",
      "fields" : [
         "firstname",
         "lastname"
      ],
      "query" : "john smith"
   }
}
'

# {
#    "_shards" : {
#       "failed" : 0,
#       "successful" : 1,
#       "total" : 1
#    },
#    "explanations" : [
#       {
#          "index" : "test",
#          "explanation" : "((+lastname:john +lastname:smith) | (+firstname:john +firstname:smith))",
#          "valid" : true
#       }
#    ],
#    "valid" : true
# }

Während query_string (mit default_operator AND) überprüfen, ob zu JEDEM Begriff existiert in mindestens einem Bereich:

curl -XGET 'http://127.0.0.1:9200/_validate/query?pretty=1&explain=true'  -d '
{
   "query_string" : {
      "fields" : [
         "firstname",
         "lastname"
      ],
      "query" : "john smith",
      "default_operator" : "AND"
   }
}
'

# {
#    "_shards" : {
#       "failed" : 0,
#       "successful" : 1,
#       "total" : 1
#    },
#    "explanations" : [
#       {
#          "index" : "test",
#          "explanation" : "+(firstname:john | lastname:john) +(firstname:smith | lastname:smith)",
#          "valid" : true
#       }
#    ],
#    "valid" : true
# }

Also haben Sie ein paar Entscheidungen zu erreichen, was Sie nach sind:

Preparse die Suchbegriffe, Dinge zu entfernen, wie wildcards, etc, bevor Sie die query_string
Preparse die Suchbegriffe zu extrahieren, jedes Wort, erzeugt dann eine multi_match Abfrage pro Wort
Verwenden index_name in deinem mapping für die name-Felder zu indizieren Ihre Daten in einem einzigen Feld, das Sie können, dann verwenden Sie für die Suche. (wie Sie Ihre eigenen benutzerdefinierten all Feld):

Wie folgt:

curl -XPUT 'http://127.0.0.1:9200/test/?pretty=1'  -d '
{
   "mappings" : {
      "test" : {
         "properties" : {
            "firstname" : {
               "index_name" : "name",
               "type" : "string"
            },
            "lastname" : {
               "index_name" : "name",
               "type" : "string"
            }
         }
      }
   }
}
'

curl -XPOST 'http://127.0.0.1:9200/test/test?pretty=1'  -d '
{
   "firstname" : "john",
   "lastname" : "smith"
}
'

curl -XGET 'http://127.0.0.1:9200/test/test/_search?pretty=1'  -d '
{
   "query" : {
      "match" : {
         "name" : {
            "operator" : "and",
            "query" : "john smith"
         }
      }
   }
}
'

# {
#    "hits" : {
#       "hits" : [
#          {
#             "_source" : {
#                "firstname" : "john",
#                "lastname" : "smith"
#             },
#             "_score" : 0.2712221,
#             "_index" : "test",
#             "_id" : "VJFU_RWbRNaeHF9wNM8fRA",
#             "_type" : "test"
#          }
#       ],
#       "max_score" : 0.2712221,
#       "total" : 1
#    },
#    "timed_out" : false,
#    "_shards" : {
#       "failed" : 0,
#       "successful" : 5,
#       "total" : 5
#    },
#    "took" : 33
# }

Beachten Sie jedoch, dass firstname und lastname sind nicht mehr durchsuchbar sind unabhängig voneinander. Die Daten für beide Felder die indiziert wurden, in name.

Könnten Sie multi-Felder mit der path parameter, Sie durchsuchbar zu machen sowohl unabhängig als auch gemeinsam, wie folgt:

curl -XPUT 'http://127.0.0.1:9200/test/?pretty=1'  -d '
{
   "mappings" : {
      "test" : {
         "properties" : {
            "firstname" : {
               "fields" : {
                  "firstname" : {
                     "type" : "string"
                  },
                  "any_name" : {
                     "type" : "string"
                  }
               },
               "path" : "just_name",
               "type" : "multi_field"
            },
            "lastname" : {
               "fields" : {
                  "any_name" : {
                     "type" : "string"
                  },
                  "lastname" : {
                     "type" : "string"
                  }
               },
               "path" : "just_name",
               "type" : "multi_field"
            }
         }
      }
   }
}
'

curl -XPOST 'http://127.0.0.1:9200/test/test?pretty=1'  -d '
{
   "firstname" : "john",
   "lastname" : "smith"
}
'

Suche im any_name - Feld funktioniert:

curl -XGET 'http://127.0.0.1:9200/test/test/_search?pretty=1'  -d '
{
   "query" : {
      "match" : {
         "any_name" : {
            "operator" : "and",
            "query" : "john smith"
         }
      }
   }
}
'

# {
#    "hits" : {
#       "hits" : [
#          {
#             "_source" : {
#                "firstname" : "john",
#                "lastname" : "smith"
#             },
#             "_score" : 0.2712221,
#             "_index" : "test",
#             "_id" : "Xf9qqKt0TpCuyLWioNh-iQ",
#             "_type" : "test"
#          }
#       ],
#       "max_score" : 0.2712221,
#       "total" : 1
#    },
#    "timed_out" : false,
#    "_shards" : {
#       "failed" : 0,
#       "successful" : 5,
#       "total" : 5
#    },
#    "took" : 11
# }

Suche firstname für john AND smith funktioniert nicht:

curl -XGET 'http://127.0.0.1:9200/test/test/_search?pretty=1'  -d '
{
   "query" : {
      "match" : {
         "firstname" : {
            "operator" : "and",
            "query" : "john smith"
         }
      }
   }
}
'

# {
#    "hits" : {
#       "hits" : [],
#       "max_score" : null,
#       "total" : 0
#    },
#    "timed_out" : false,
#    "_shards" : {
#       "failed" : 0,
#       "successful" : 5,
#       "total" : 5
#    },
#    "took" : 2
# }

Aber auf der Suche firstname für nur john korrekt funktioniert:

curl -XGET 'http://127.0.0.1:9200/test/test/_search?pretty=1'  -d '
{
   "query" : {
      "match" : {
         "firstname" : {
            "operator" : "and",
            "query" : "john"
         }
      }
   }
}
'

# {
#    "hits" : {
#       "hits" : [
#          {
#             "_source" : {
#                "firstname" : "john",
#                "lastname" : "smith"
#             },
#             "_score" : 0.30685282,
#             "_index" : "test",
#             "_id" : "Xf9qqKt0TpCuyLWioNh-iQ",
#             "_type" : "test"
#          }
#       ],
#       "max_score" : 0.30685282,
#       "total" : 1
#    },
#    "timed_out" : false,
#    "_shards" : {
#       "failed" : 0,
#       "successful" : 5,
#       "total" : 5
#    },
#    "took" : 3
# }

InformationsquelleAutor DrTech

1

Würde ich eher vermeiden, mit query_string im Fall übergibt der Benutzer "ODER", "UND" und die anderen advanced params.

In meiner Erfahrung, die Maskierung von Sonderzeichen mit dem backslash ist eine einfache und effektive Lösung. Die Liste finden Sie in der Dokumentation http://lucene.apache.org/core/4_5_0/queryparser/org/apache/lucene/queryparser/classic/package-summary.html#package_description -, plus-UND/ODER/NICHT/ZU.

InformationsquelleAutor Ranz
0

Denke ich, dass "match" - Abfrage ist das, was Sie suchen:

"Das Spiel Familie von Abfragen geht nicht durch einen "query parsing" - Prozess. Es unterstützt keine Feldnamen Präfixe, wildcard-Zeichen, oder andere "erweiterte" Funktionen. Aus diesem Grund Chancen, dass es andernfalls sehr klein /nicht vorhanden, und es bietet einen hervorragendes Verhalten, wenn es um genau analysieren und ausführen, die text-als-query-Verhalten (das ist normalerweise das, was ein text-Suchfeld hat)"

http://www.elasticsearch.org/guide/reference/query-dsl/match-query.html

InformationsquelleAutor runarM
0

Heutzutage können Sie cross_fields geben multi_match
```
GET /_validate/query?explain
{
    "query": {
        "multi_match": {
            "query":       "peter smith",
            "type":        "cross_fields", 
            "operator":    "and",
            "fields":      [ "firstname", "lastname", "middlename" ]
        }
    }
}
```
Cross-Felder nehmen einen Begriff-zentrierten Ansatz. Es behandelt alle Felder zu einem großen Feld, und sieht für jeden Begriff in jedem Bereich.

Eine Sache zu beachten ist jedoch, dass, wenn Sie wollen, dass es optimal funktioniert, werden alle Felder analysiert werden, sollten die gleichen analyzer (standard, Englisch, etc.):

Für die cross_fields Abfrage geben, um optimal arbeiten, alle Felder sollten
habe das gleiche analyzer. Felder, die gemeinsam ein Analysegerät zusammengefasst sind
zusammen blended Felder.

Wenn Sie Felder mit einer unterschiedlichen Analyse-Kette, Sie werden
Hinzugefügt, um die Abfrage in der gleichen Weise wie für best_fields. Zum Beispiel,
wenn wir das Titel-Feld, um die Vorherige Abfrage (vorausgesetzt, es setzt ein
verschiedene analyzer), die Erklärung wäre wie folgt:

(+Titel:peter +Titel:smith) ( +gemischt("peter", Felder: [first_name,
last_name]) +blended("smith", Felder: [first_name, last_name]) )

InformationsquelleAutor Aziz Javed

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.