elasticsearch बूल क्वेरी गठबंधन को OR के साथ होना चाहिए

Question

मैं वर्तमान में एक सॉलिट-आधारित एप्लिकेशन को इलास्टिक्सखोज में माइग्रेट करने का प्रयास कर रहा हूं।

मेरे पास यह आकर्षक क्वेरी है

(( 
    name:(+foo +bar) 
    OR info:(+foo +bar) 
)) AND state:(1) AND (has_image:(0) OR has_image:(1)^100)

जहां तक ​​मैं समझता हूं कि यह बस्टियन के साथ संयुक्त MUST क्लॉस का एक संयोजन है:

"(नाम में फू और बार) या (जानकारी में फू और बार) वाले सभी दस्तावेजों को प्राप्त करें। उसके बाद हालत राज्य = 1 द्वारा फ़िल्टर परिणाम और एक छवि वाले दस्तावेज़ों को बढ़ावा दें।"

मैं MUST के साथ बूल क्वेरी का उपयोग करने की कोशिश कर रहा हूं, लेकिन मैं बूलियन प्राप्त करने में विफल रहा हूं या क्लॉस में होना चाहिए। यही सब कुछ मेरे पास है:

GET /test/object/_search
{
  "from": 0,
  "size": 20,
  "sort": {
    "_score": "desc"
  },
  "query": {
    "bool": {
      "must": [
        {
          "match": {
            "name": "foo"
          }
        },
        {
          "match": {
            "name": "bar"
          }
        }
      ],
      "must_not": [],
      "should": [
        {
          "match": {
            "has_image": {
              "query": 1,
              "boost": 100
            }
          }
        }
      ]
    }
  }
}

जैसा कि आप देख सकते हैं, "जानकारी" के लिए जरूरी शर्तें गायब हैं।

क्या किसी के पास एक समाधान है?

बहुत बहुत धन्यवाद।

** अपडेट करें **

मैंने अपनी इलास्टिक्स खोज क्वेरी को अपडेट किया है और उस फ़ंक्शन स्कोर से छुटकारा पा लिया है। मेरी आधार समस्या अभी भी मौजूद है।

Comments

: वहाँ ElasticSearch के संयोजन पर एक अच्छा प्रलेखन क्वेरी काम यहाँ है elastic.co/guide/en/elasticsearch/guide/current/...

— Mr.Coffee

Answer 1

• या वर्तनी है चाहिए
• और वर्तनी है चाहिए
• NOR वर्तनी है_ नहीं

उदाहरण:

आप सभी आइटम देखना चाहते हैं जो (गोल और लाल या नीला) हैं:

{
    "query": {
        "bool": {
            "must": [
                {
                    "term": {"shape": "round"}
                },
                {
                    "bool": {
                        "should": [
                            {"term": {"color": "red"}},
                            {"term": {"color": "blue"}}
                        ]
                    }
                }
            ]
        }
    }
}

आप OR के अधिक जटिल संस्करण भी कर सकते हैं, उदाहरण के लिए यदि आप 5 में से कम से कम 3 से मेल खाना चाहते हैं, तो आप "चाहिए" के तहत 5 विकल्प निर्दिष्ट कर सकते हैं और 3 का "न्यूनतम_शोल्ड" सेट कर सकते हैं।

ग्लेन थॉम्पसन और सेबेस्टियलोनो को खोजने के लिए धन्यवाद, जहां मेरा घोंसला पहले ठीक नहीं था।

यह बताने के लिए भी कि फातमाजक का धन्यवाद "इलास्टिक 6" में "मैच" बन जाता है।

Comments

shouldऊपरी स्तर में खींच कर bool, और एक minimum_should_match: 1काम भी शामिल होगा?

— सिड

जब मैं इस उदाहरण की कोशिश करता हूं तो मुझे वापस मिल जाता है [term] malformed query, expected [END_OBJECT] but found [FIELD_NAME]। क्या यह किसी तरह संस्करण पर निर्भर है?

— DanneJ

वे डॉक्स में ऐसा सरल उदाहरण और स्पष्टीकरण क्यों नहीं जोड़ते हैं! प्रलेखन से उदाहरण बहुत भ्रामक है।

— निखिल ओवलेकर

6 महीने के बाद, सभी इलास्टिक प्रलेखन को पढ़ना, यह पहली बार है जब मैं पूरी तरह से समझता हूं कि बूलियन तर्क को कैसे लागू किया जाए। आधिकारिक दस्तावेज में मेरी राय में स्पष्टता का अभाव है।

— सेबेस्टियलोनो

@ क्या मैं आपके लिए सफाई कर सकता हूं? ऊपर दिखाए गए संदर्भ में, डिफ़ॉल्ट minimum_should1 है, और boolउस समूह के परिणामों में यह लपेटकर सत्य है कि कम से कम एक आइटम मेल खाता है, तो कोई भी मिलान के बिना गलत है। इस उत्तर को बनाने के लिए मेरी प्रेरणा यह थी कि मैं इस तरह की समस्या को हल कर रहा था, और उपलब्ध दस्तावेज और यहां तक ​​कि उत्तर जो मुझे इस तरह की साइटों पर मिल सकते थे, वह सबसे अच्छा था, इसलिए मैंने तब तक शोध किया जब तक मुझे लगा कि मेरे पास एक बहुत ठोस समझ है क्या चल रहा था मैं ख़ुशी से किसी भी रचनात्मक संकेत का स्वागत करता हूँ कि मैं उत्तर को और बेहतर कैसे बना सकता हूँ।

— डैनियल फेकेल

Answer 2

मैंने आखिर में एक क्वेरी बनाने में कामयाबी हासिल की, जो मैं चाहता था:

एक फ़िल्टर्ड नेस्टेड बूलियन क्वेरी। मुझे यकीन नहीं है कि यह दस्तावेज क्यों नहीं है। शायद यहाँ कोई मुझे बता सकता है?

यहाँ प्रश्न है:

GET /test/object/_search
{
  "from": 0,
  "size": 20,
  "sort": {
    "_score": "desc"
  },
  "query": {
    "filtered": {
      "filter": {
        "bool": {
          "must": [
            {
              "term": {
                "state": 1
              }
            }
          ]
        }
      },
      "query": {
        "bool": {
          "should": [
            {
              "bool": {
                "must": [
                  {
                    "match": {
                      "name": "foo"
                    }
                  },
                  {
                    "match": {
                      "name": "bar"
                    }
                  }
                ],
                "should": [
                  {
                    "match": {
                      "has_image": {
                        "query": 1,
                        "boost": 100
                      }
                    }
                  }
                ]
              }
            },
            {
              "bool": {
                "must": [
                  {
                    "match": {
                      "info": "foo"
                    }
                  },
                  {
                    "match": {
                      "info": "bar"
                    }
                  }
                ],
                "should": [
                  {
                    "match": {
                      "has_image": {
                        "query": 1,
                        "boost": 100
                      }
                    }
                  }
                ]
              }
            }
          ],
          "minimum_should_match": 1
        }
      }    
    }
  }
}

छद्म एसक्यूएल में:

SELECT * FROM /test/object
WHERE 
    ((name=foo AND name=bar) OR (info=foo AND info=bar))
AND state=1

कृपया ध्यान रखें कि यह आपके दस्तावेज़ क्षेत्र विश्लेषण और मैपिंग पर निर्भर करता है कि नाम = फू आंतरिक रूप से कैसे नियंत्रित किया जाता है। यह एक फजी से सख्त व्यवहार के लिए भिन्न हो सकता है।

"minimal_should_match": 1 कहता है, कि कम से कम एक कथन सही होना चाहिए।

इस कथन का अर्थ है कि जब भी has_image: 1 के परिणाम में कोई दस्तावेज़ होता है, तो इसे कारक 100 द्वारा बढ़ाया जाता है। यह आदेश को बदलता है।

"should": [
  {
    "match": {
      "has_image": {
        "query": 1,
        "boost": 100
      }
    }
   }
 ]

साथियो आनंद लो :)

Comments

बकवास। क्या किसी के पास बेहतर उपाय है? इसे पोस्ट करने के लिए धन्यवाद, लेकिन यह एक तार्किक या एक क्वेरी में प्राप्त करने के लिए बहुत अधिक जटिलता है।

— nackjicholson

thnx, आपने मेरा दिन बचाया)

— क्यूबाई

न केवल यह क्वेरी अनावश्यक रूप से लंबी है, इसका उपयोग अपघटित वाक्यविन्यास है। @ डेनियल-फेकेल का उत्तर स्वीकार किया जाना चाहिए।

— एरिक अल्फोर्ड

@EricAlford 2015 का यह उत्तर ES के पुराने संस्करण पर आधारित है। एक बेहतर समाधान प्रदान करने के लिए स्वतंत्र महसूस करें।

— जेसी

आइडिया: ElasticSearch को ओवर / फोर्क लें, इसे उपयोगकर्ता के अनुकूल तरीके से फिर से लिखें, इसमें सरल क्वेरी भाषा जोड़ें, जीतो! हमें सिर्फ फंडिंग की जरूरत है। मैं भी शामिल! और कौन ?

— सालिक

Answer 3

इस तरह से आप एक बाहरी बूल क्वेरी में कई बूल क्वेरी को घोंसला कर सकते हैं, यह किबाना का उपयोग करते हुए,

बूल इंगित करता है कि हम बूलियन का उपयोग कर रहे हैं

AND के लिए होना चाहिए

चाहिए के लिए है या

GET my_inedx/my_type/_search
{
    "query" : {
       "bool": {             //bool indicates we are using boolean operator
            "must" : [       //must is for **AND**
                 {
                   "match" : {
                         "description" : "some text"  
                     }
                 },
                 {
                    "match" :{
                          "type" : "some Type"
                     }
                 },
                 {
                    "bool" : {          //here its a nested boolean query
                          "should" : [  //should is for **OR**
                                 {
                                   "match" : {
                                       //ur query
                                  }
                                 },
                                 { 
                                    "match" : {} 
                                 }     
                               ]
                          }
                 }
             ]
        }
    }
}

यह है कि आप ES में क्वेरी कैसे कर सकते हैं

"बूल" में और प्रकार होते हैं जैसे -

1. फ़िल्टर

2. बिलकुल मना है

Comments

आपका उत्तर बिल्कुल सही है, लेकिन यह थोड़ा अनाड़ी है, यह आपके लिए एक छोटा सुझाव है यदि आप चाहें - तो आपको इसे ठीक से संपादित करना होगा। संभवतः यह आपको इस उत्तर पर अधिक पसंद करता है :) आपका दिन अच्छा हो।

— 5

Answer 4

मुझे हाल ही में इस समस्या को भी हल करना पड़ा, और बहुत सारे परीक्षण और त्रुटि के बाद मैं इस (PHP में, लेकिन सीधे डीएसएल के नक्शे) के साथ आया:

'query' => [
    'bool' => [
        'should' => [
            ['prefix' => ['name_first' => $query]],
            ['prefix' => ['name_last' => $query]],
            ['prefix' => ['phone' => $query]],
            ['prefix' => ['email' => $query]],
            [
                'multi_match' => [
                    'query' => $query,
                    'type' => 'cross_fields',
                    'operator' => 'and',
                    'fields' => ['name_first', 'name_last']
                ]
            ]
        ],
        'minimum_should_match' => 1,
        'filter' => [
            ['term' => ['state' => 'active']],
            ['term' => ['company_id' => $companyId]]
        ]
    ]
]

SQL में कुछ इस तरह के नक्शे:

SELECT * from <index> 
WHERE (
    name_first LIKE '<query>%' OR
    name_last LIKE '<query>%' OR
    phone LIKE  '<query>%' OR
    email LIKE '<query>%'
)
AND state = 'active'
AND company_id = <query>

इस सब में कुंजी minimum_should_matchसेटिंग है। इसके बिना filterपूरी तरह से ओवरराइड होता है should।

आशा है कि यह किसी की मदद करता है!

Answer 5

$filterQuery = $this->queryFactory->create(QueryInterface::TYPE_BOOL, ['must' => $queries,'should'=>$queriesGeo]);

में mustआप क्वेरी हालत सरणी जो आप के साथ काम करना चाहते हैं जोड़ने की जरूरत है ANDऔर में shouldआप क्वेरी शर्त है जो आप के साथ काम करना चाहते हैं जोड़ने की जरूरत है OR।

आप इसे देख सकते हैं: https://github.com/Smile-SA/elasticsuite/issues/972

Answer 6

यदि आप सोलर डिफ़ॉल्ट या ल्यूसीन क्वेरी पार्सर का उपयोग कर रहे थे, तो आप इसे हमेशा एक क्वेरी स्ट्रिंग क्वेरी में डाल सकते हैं :

POST test/_search
{
  "query": {
    "query_string": {
      "query": "(( name:(+foo +bar) OR info:(+foo +bar)  )) AND state:(1) AND (has_image:(0) OR has_image:(1)^100)"
    }
  }
}

उस ने कहा, आप एक बूलियन क्वेरी का उपयोग करना चाहते हैं , जैसे कि आप पहले से ही पोस्ट कर रहे हैं, या यहां तक ​​कि दो का संयोजन भी।