लोचदार खोज फ़ज़ी वाक्यांश

Question

मेरे पास अपनी खोज में फ़ज़ीनेस जोड़ने के लिए निम्न क्वेरी है। हालांकि, अब मुझे एहसास है कि मिलान क्वेरी खोज स्ट्रिंग में शब्दों के क्रम पर विचार नहीं करती है, क्योंकि match_phrase करता है। हालांकि, मुझे fuzziness के साथ परिणाम देने के लिए match_phrase नहीं मिल सकता है। शब्दों के बीच आदेश और दूरी पर विचार करने के लिए मैच बताने का कोई तरीका है?

{ 
    "query": { 
     "match": { 
      "content": { 
       "query": "some search terms like this", 
       "fuzziness": 1, 
       "operator": "and" 
      } 
     } 
    } 
} 

Answer 1

आखिरकार पता लगा है कि मैं span प्रश्नों, जो fuzziness और ढिलाई के लिए ट्यूनिंग का एक बहुत अच्छा राशि देने के संयोजन का उपयोग करने के लिए आवश्यक। मैं एक प्रोग्राम के रूप में "खंड" सरणी के लिए एक समारोह मैन्युअल मेरी वाक्यांशों tokenize और जोड़ने के लिए जोड़ने के लिए की जरूरत:

{"query": 
{ 
    "span_near": { 
    "clauses": [ 
     { 
     "span_multi": { 
      "match": { 
      "fuzzy": { 
       "content": { 
       "fuzziness": "2", 
       "value": "word" 
       } 
      } 
      } 
     } 
     }, 
     { 
     "span_multi": { 
      "match": { 
      "fuzzy": { 
       "content": { 
       "fuzziness": "2", 
       "value": "another" 
       } 
      } 
      } 
     } 
     }     
    ], 
    "slop": 1, 
    "in_order": "true" 

Answer 2

@econgineer बहुत बढ़िया पोस्ट। लेकिन मैं बहुत JSON डेटा कर रखने के लिए आलसी हूँ ....

मुझे लगता है कि इस कोड काम करता है ... अजीब यह करने के लिए JQ का कारण बनता है -

मैं एक ES क्वेरी के लिए यह प्रयास करने के लिए हम पर काम कर रहे चाहता था शिकायत लेकिन ElasticSearch काम ....

import json 
import pprint 
from collections import defaultdict 
nested_dict = lambda: defaultdict(nested_dict) 
query=nested_dict() 
query['span_near']['clauses']=list() 
query['slop']='1' 
query['in_order']="true" 


words=['what','is','this'] 
for w in words: 
    nest = nested_dict() 
    nest["span_multi"]["match"]["fuzzy"]["msg"]["fuzziness"]["value"]=w 
    nest["span_multi"]["match"]["fuzzy"]["msg"]["fuzziness"]["fuzziness"]="2" 
    json.dumps(nest) 
    query['span_near']['clauses'].append(json.loads(json.dumps(nest))) 


pprint.pprint(json.loads(json.dumps(query))) 

आप द्वारा

cat t2.json | tr "\'" "\"" | jq '.' 

उत्पादन सुशोभित यदि आप देखना चाहिए कुछ तरह

0,123,

{ 
    "in_order": "true", 
    "slop": "1", 
    "span_near": { 
    "clauses": [ 
     { 
     "span_multi": { 
      "match": { 
      "fuzzy": { 
       "msg": { 
       "fuzziness": { 
        "fuzziness": "2", 
        "value": "what" 
       } 
       } 
      } 
      } 
     } 
     }, 
     { 
     "span_multi": { 
      "match": { 
      "fuzzy": { 
       "msg": { 
       "fuzziness": { 
        "fuzziness": "2", 
        "value": "is" 
       } 
       } 
      } 
      } 
     } 
     }, 
     { 
     "span_multi": { 
      "match": { 
      "fuzzy": { 
       "msg": { 
       "fuzziness": { 
        "fuzziness": "2", 
        "value": "this" 
       } 
       } 
      } 
      } 
     } 
     } 
    ] 
    } 
} 

और फिर क्वेरी करने के लिए यह

curl --silent My_ES_Server:9200:/INDEX/_search -d @t2.json 

प्रारंभिक मार्गदर्शन के लिए बहुत-बहुत धन्यवाद सिर्फ एक सामान्य है es, मुझे आशा है कि किसी और उपयोग की इस पाते हैं।

Answer 3

वास्तव में, एक उत्कृष्ट प्रश्न और उत्तर। मुझे आश्चर्य है कि इस 'अस्पष्ट वाक्यांश मैच' में बॉक्स से समर्थन नहीं है।

यहां एक परीक्षण किया गया नोडजेएस कोड है जो एक बहु खोज (msearch) के संदर्भ में अस्पष्ट वाक्यांश मिलान (बहु खंड) क्वेरी ब्लॉक उत्पन्न करता है, लेकिन इसे एक ही खोज के साथ ही काम करना चाहिए।

उपयोग:

let queryBody = []; 
client.msearch({ 
    body: queryBody 
}) 

queryBody.push({ index: 'YOUR_INDEX' }); 
queryBody.push(createESFuzzyPhraseQueryBlock('YOUR PHRASE', 'YOUR_FIELD_NAME', 2)); // 2 <- fuzziness 

कार्य:

const createESFuzzyPhraseClauseBlock = (word, esFieldName, fuzziness) => { 
    let clauseBlock = JSON.parse(
     `{ 
      "span_multi": { 
       "match": { 
        "fuzzy": { 
         "${esFieldName}": { 
          "fuzziness": "${fuzziness}", 
          "value": "${word}" 
         } 
        } 
       } 
      } 
     }`); 

    return clauseBlock; 
}; 


const createESFuzzyPhraseQueryBlock = (phrase, esFieldName, fuzziness) => { 
    let clauses = []; 

    let words = phrase.split(' '); 
    words.forEach(word => clauses.push(createESFuzzyPhraseClauseBlock(word, esFieldName, fuzziness))); 

    let queryBlock = 
     { 
      "query": 
       { 
        "span_near": { 
         "clauses": clauses, 
         "slop": 1, 
         "in_order": "true" 
        } 
       } 
     }; 

    return queryBlock; 
};