क़्वाड्रेन्ट गुणवत्ता फ़िल्टरिंग

फ़िल्टर

Qdrant के साथ, आप बिंदुओं को खोजने या प्राप्त करने के लिए शर्तें सेट कर सकते हैं, जिसका मतलब है आप वेक्टरों के समानता खोज के अतिरिक्त विशेषता के अनुसार फ़िल्टर कर सकते हैं, SQL where शर्तों को सेट करने के तरह। उदाहरण के लिए, आप बिंदु के पेलोड और id के लिए शर्तें सेट कर सकते हैं।

जब एक वस्तु की सभी विशेषताएँ एक एम्बेडिंग में व्यक्त नहीं की जा सकती, तो अतिरिक्त शर्तें सेट करना महत्वपूर्ण है। उदाहरण के लिए, विभिन्न व्यावसायिक आवश्यकताएँ जैसे इन्वेंटरी उपलब्धता, उपयोगकर्ता स्थान, या अपेक्षित मूल्य सीमा।

फ़िल्टर शर्तें

Qdrant आपको क्लॉज़ में शर्तों को कंबाइन करने की अनुमति देता है। क्लॉज़ विभिन्न तार्किक क्रियाएँ हैं, जैसे कि OR, AND, और NOT। क्लॉज़ को एक दूसरे के भीतर पुनरावर्ती नेस्ट किया जा सकता है, ताकि आप किसी भी सत्यात्मक अभिव्यक्ति को पुनर्रचित कर सकें।

चलिए देखते हैं Qdrant में लागू क्लॉज़ को।

मान लीजिए हमारे पास पेलोड के साथ एक सेट बिंदु हैं:

[
  { "id": 1, "city": "लंदन", "color": "हरा" },
  { "id": 2, "city": "लंदन", "color": "लाल" },
  { "id": 3, "city": "लंदन", "color": "नीला" },
  { "id": 4, "city": "बर्लिन", "color": "लाल" },
  { "id": 5, "city": "मॉस्को", "color": "हरा" },
  { "id": 6, "city": "मॉस्को", "color": "नीला" }
]

आवश्यक

उदाहरण:

POST /collections/{collection_name}/points/scroll

{
    "filter": {
        "must": [
            { "key": "city", "match": { "value": "लंदन" } },
            { "key": "color", "match": { "value": "लाल" } }
        ]
    }
  ...
}

फ़िल्टर किया गया बिंदु होगा:

[{ "id": 2, "city": "लंदन", "color": "लाल" }]

must का उपयोग करते समय, क्लॉज सत्य है केवल तब, जब प्रत्येक शर्त जो must में सूचीबद्ध की गई है, पूरी हो। इस मान में, must को AND ऑपरेटर के समान माना जा सकता है।

चाहिए

चाहिए SQL के OR ऑपरेटर के समान है।

उदाहरण:

POST /collections/{collection_name}/points/scroll

{
    "filter": {
        "should": [
            { "key": "city", "match": { "value": "लंदन" } },
            { "key": "color", "match": { "value": "लाल" } }
        ]
    }
  ...
}

फ़िल्टर किए गए बिंदु हैं:

[
  { "id": 1, "city": "लंदन", "color": "हरा" },
  { "id": 2, "city": "लंदन", "color": "लाल" },
  { "id": 3, "city": "लंदन", "color": "नीला" },
  { "id": 4, "city": "बर्लिन", "color": "लाल" }
]

चाहिए का उपयोग करते समय, क्लॉज तब सत्य होता है, जब तक कम से कम एक शर्त जो चाहिए में सूचीबद्ध की गई है, पूरी हो। इस मान में, चाहिए को OR ऑपरेटर के समान माना जा सकता है।

must_not

उदाहरण:

POST /collections/{collection_name}/points/scroll

{
    "filter": {
        "must_not": [
            { "key": "city", "match": { "value": "लंदन" } },
            { "key": "color", "match": { "value": "लाल" } }
        ]
    }
  ...
}

फ़िल्टर किए गए बिंदु हैं:

[
  { "id": 5, "city": "मॉस्को", "color": "हरा" },
  { "id": 6, "city": "मॉस्को", "color": "नीला" }
]

must_not का उपयोग करते समय, उप-क्लॉज केवल तब सत्य है, जब must_not में सूचीबद्ध सभी शर्तें संतुष्ट न हो। इस मान में, must_not को व्यक्ति व्यक्ति चेन व्AND ऑपरेटर के समान माना जा सकता है।

शर्तों का संयोजन

कई शर्तों का समयोजन संभव है:

POST /collections/{collection_name}/points/scroll

{
    "filter": {
        "must": [
            { "key": "city", "match": { "value": "लंदन" } }
        ],
        "must_not": [
            { "key": "color", "match": { "value": "लाल" } }
        ]
    }
  ...
}

फ़िल्टर किए गए बिंदु होंगे:

[
  { "id": 1, "city": "लंदन", "color": "हरा" },
  { "id": 3, "city": "लंदन", "color": "नीला" }
]

इस मामले में, शर्तें AND का उपयोग करके संयोजित की गई हैं।

इसके अतिरिक्त, शर्तों को आपक्रमिक रूप से नेस्ट किया जा सकता है। उदाहरण के लिए:

POST /collections/{collection_name}/points/scroll

{
    "filter": {
        "must_not": [
            {
                "must": [
                    { "key": "city", "match": { "value": "लंदन" } },
                    { "key": "color", "match": { "value": "लाल" } }
                ]
            }
        ]
    }
  ...
}

फ़िल्टर किए गए बिंदु होंगे:

[
  { "id": 1, "city": "लंदन", "color": "हरा" },
  { "id": 3, "city": "लंदन", "color": "नीला" },
  { "id": 4, "city": "बर्लिन", "color": "लाल" },
  { "id": 5, "city": "मॉस्को", "color": "हरा" },
  { "id": 6, "city": "मॉस्को", "color": "नीला" }
]

शर्त फ़िल्टरिंग

पेयलोड में, विभिन्न प्रकार की मानें उन प्रकारों के लिए लागू किए जा सकते हैं जिनमें विद्यमान शर्तों के विविध रूपों की जांच की जा सकती है। आओ हम वर्तमान शर्त विविधताओं और उनके लागू होने वाले डेटा प्रकारों की ओर एक नज़र डालें।

मैचिंग

{
  "key": "color",
  "match": {
    "value": "लाल"
  }
}

अन्य प्रकारों के लिए, मैचिंग शर्तें बिल्कुल ऐसी दिखती हैं, पर विभिन्न प्रकारों का प्रयोग करती हैं:

{
  "key": "count",
  "match": {
    "value": 0
  }
}

सबसे सरल शर्त यह जाँचती है कि क्या भंडारित मान दिए गए मान के समान है। यदि एक से अधिक मान संग्रहित होते हैं, तो कम से कम एक उनमें से शर्त को पूरा करना चाहिए। यह कीवर्ड, पूर्णांक, और बूलियन पेयलोड पर लागू किया जा सकता है।

किसी भी मैच

• v1.1.0 से उपलब्ध *

यदि आप चाहते हैं कि भंडारित मान में से कोई भी मान हो, तो आप किसी भी मैच शर्त का उपयोग कर सकते हैं। किसी भी मैच दिए गए मान को एक तार्किक OR परिचालन के रूप में देखती है। इसे यहाँ IN ऑपरेटर के रूप में भी वर्णित किया जा सकता है।

इसे कीवर्ड और पूर्णांक पेयलोड पर लागू किया जा सकता है।

उदाहरण:

{
  "key": "color",
  "match": {
    "any": ["काला", "पीला"]
  }
}

इस उदाहरण में, यदि भंडारित मान काला या पीला है, तो शर्त पूरी होगी।

यदि भंडारित मान एक एरे है, तो उसमें से कम से कम एक मान कोई भी दिए गए मानों में से किसी भी मान को पूरा करना चाहिए। उदाहरण के लिए, यदि भंडारित मान ["काला", "हरा"] है, तो शर्त पूरी होगी क्योंकि "काला" ["काला", "पीला"] में है।

अनुलक्षण मैच

• v1.2.0 से उपलब्ध *

यदि आप चाहते हैं कि भंडारित मान विभिन्न मानों में से कोई नहीं हो, तो आप अनुलक्षण मैच शर्त का उपयोग कर सकते हैं। अनुलक्षण मैच दिए गए मान को तार्किक NOR परिचालन के रूप में देखती है। इसे NOT IN ऑपरेटर के रूप में भी वर्णित किया जा सकता है।

इसे कीवर्ड और पूर्णांक पेयलोड पर लागू किया जा सकता है।

उदाहरण:

{
  "key": "color",
  "match": {
    "except": ["काला", "पीला"]
  }
}

इस उदाहरण में, यदि भंडारित मान न तो काला है और न ही पीला, तो शर्त पूरी होगी।

अगर भंडारित मान एक एरे है, तो उसमें से कम से कम एक मान दिए गए मानों में से किसी भी मान को पूरा करना चाहिए। उदाहरण के लिए, यदि भंडारित मान ["काला", "हरा"] है, तो शर्त पूरी होगी क्योंकि "हरा" "काला" या "पीला" से मेल नहीं खाता है।

नेस्टेड कुंजी

v1.1.0 के बाद उपलब्ध

क्योंकि पेलोड एक अन्यायिक JSON ऑब्जेक्ट है, इसलिए आपको नेस्टेड फ़ील्ड को फ़िल्टर करने की आवश्यकता हो सकती है।

सुविधा के लिए, हम Jq प्रोजेक्ट के समान संज्ञाना का उपयोग करते हैं।

मान लीजिए हमारे पास निम्नलिखित पेलोड के साथ कुछ बिंदु हैं:

[
  {
    "id": 1,
    "country": {
      "name": "Germany",
      "cities": [
        {
          "name": "Berlin",
          "population": 3.7,
          "sightseeing": ["Brandenburg Gate", "Reichstag"]
        },
        {
          "name": "Munich",
          "population": 1.5,
          "sightseeing": ["Marienplatz", "Olympiapark"]
        }
      ]
    }
  },
  {
    "id": 2,
    "country": {
      "name": "Japan",
      "cities": [
        {
          "name": "Tokyo",
          "population": 9.3,
          "sightseeing": ["Tokyo Tower", "Tokyo Skytree"]
        },
        {
          "name": "Osaka",
          "population": 2.7,
          "sightseeing": ["Osaka Castle", "Universal Studios Japan"]
        }
      ]
    }
  }
]

आप डॉट संकेतन का उपयोग करके नेस्टेड फ़ील्ड्स के लिए खोज कर सकते हैं।

POST /collections/{collection_name}/points/scroll

{
    "filter": {
        "should": [
            {
                "key": "country.name",
                "match": {
                    "value": "Germany"
                }
            }
        ]
    }
}

आप इनर मानों को प्रोजेक्ट करके एरे कोड भी का उपयोग कर सकते हैं।

POST /collections/{collection_name}/points/scroll

{
    "filter": {
        "should": [
            {
                "key": "country.cities[].population",
                "range": {
                    "gte": 9.0,
                }
            }
        ]
    }
}

यह क्वेरी केवल id 2 के साथ आउटपुट करती है, क्योंकि केवल जापान में एक ऐसा शहर है जिसकी जनसंख्या 9.0 से अधिक है।

नेस्टेड फ़ील्ड भी एक ऐरे हो सकती है।

POST /collections/{collection_name}/points/scroll

{
    "filter": {
        "should": [
            {
                "key": "country.cities[].sightseeing",
                "match": {
                    "value": "Osaka Castle"
                }
            }
        ]
    }
}

यह क्वेरी केवल id 2 के साथ आउटपुट करती है, क्योंकि केवल जापान में एक ऐसा शहर है जिसमें "Osaka Castle" शामिल है।

नेस्टेड ऑब्जेक्ट फ़िल्टरिंग

संस्करण 1.2.0 से उपलब्ध

डिफ़ॉल्ट रूप से, शर्तें एक बिंदु के पूरे पेमेंट को ध्यान में रखती हैं।

उदाहरण के लिए, नीचे दिए गए पेमेंट में दो बिंदुओं को दिया गया है:

[
  {
    "id": 1,
    "dinosaur": "t-rex",
    "diet": [
      { "food": "leaves", "likes": false},
      { "food": "meat", "likes": true}
    ]
  },
  {
    "id": 2,
    "dinosaur": "diplodocus",
    "diet": [
      { "food": "leaves", "likes": true},
      { "food": "meat", "likes": false}
    ]
  }
]

निम्नलिखित क्वेरी इन दो बिंदुओं के समान होगी:

POST /collections/{collection_name}/points/scroll

{
    "filter": {
        "must": [
            {
                "key": "diet[].food",
                  "match": {
                    "value": "meat"
                }
            },
            {
                "key": "diet[].likes",
                  "match": {
                    "value": true
                }
            }
        ]
    }
}

ऊपर के दो बिंदु इसलिए मेल खाते हैं क्योंकि वे दोनों इन दो शर्तों को पूरा करते हैं:

• "t-rex" शर्त diet[1].food को खुराक = meat और diet[1].likes को पसंद = true पूरा करता है
• "diplodocus" शर्त diet[1].food को खुराक = meat और diet[0].likes को पसंद = true को पूरा करता है

अर्रेलेमेंट के लिए केवल उन बिंदुओं को प्राप्त करने के लिए जो शर्तों को पूरा करते हैं, उदाहरण के लिए, इस उदाहरण में id 1 वाला बिंदु, आपको नेस्टेड ऑब्ज

सीमा

{
  "key": "price",
  "range": {
    "gt": null,
    "gte": 100.0,
    "lt": null,
    "lte": 450.0
  }
}

रेंज शर्त स्टोर किए गए पेयलोड के लिए मानों की संभावित सीमा सेट करती है। यदि कई मान संग्रहीत हैं, तो कम से कम एक मान शर्त को मेल करना चाहिए।

उपलब्ध तुलना ऑपरेशन में शामिल हैं:

• gt - से अधिक
• gte - से अधिक या बराबर
• lt - से कम
• lte - से कम या बराबर

यह स्थापित किया जा सकता है दशांश संख्याओं और पूर्णांक पेयलोड्स पर।

भौगोलिक सीमा बॉक्स

{
  "key": "location",
  "geo_bounding_box": {
    "bottom_right": {
      "lat": 52.495862,
      "lon": 13.455868
    },
    "top_left": {
      "lat": 52.520711,
      "lon": 13.403683
    }
  }
}

यह स्थान को नीचे दाएं कोण में bottom_right और ऊपर बाएं कोण में top_left की संयोजित वर्ग के भीतर मेल खाता है।

भौगोलिक त्रिज्या

{
  "key": "location",
  "geo_radius": {
    "center": {
      "lat": 52.520711,
      "lon": 13.403683
    },
    "radius": 1000.0
  }
}

यह स्थान के भीतर केंद्र पर और त्रिज्या मीटर के त्रिज्या के वृत्त में मेल खाता है।

यदि कई मान संग्रहीत हैं, तो कम से कम एक मान शर्त को मेल करना चाहिए। यह शर्तें केवल भौगोलिक डेटा प्रारूप से मेल खाते पेयलोड्स पर लागू की जा सकती हैं।

मान गणना

सीधे मान तुलना के अलावा, फ़िल्टरिंग केवल मानों की संख्या पर भी आधारित हो सकती है।

उदाहरण के लिए, निम्नलिखित डेटा दिया गया है:

[
  { "id": 1, "name": "उत्पाद A", "comments": ["बहुत अच्छा!", "उत्कृष्ट"] },
  { "id": 2, "name": "उत्पाद B", "comments": ["उचित", "अधिक अपेक्षा", "अच्छा"] }
]

हम केवल दो से अधिक टिप्पणियों वाले आइटम्स की खोज कर सकते हैं:

{
  "key": "comments",
  "values_count": {
    "gt": 2
  }
}

परिणाम होगा:

[{ "id": 2, "name": "उत्पाद B", "comments": ["उचित", "अधिक अपेक्षा", "अच्छा"] }]

यदि संग्रहित मान एक ऐरे नहीं है, तो मान की संख्या को बराबर 1 माना जाता है।

रिक्त है

कभी-कभी, क्यामताल रिकॉर्ड जिनमें कुछ मान नहीं होते हैं, को फ़िल्टर करना उपयोगी होता है। IsEmpty शर्त आपको यह प्राप्त करने में सहायता कर सकती है:

{
  "is_empty": {
    "key": "reports"
  }
}

यह शर्त उन सभी रिकॉर्ड्स से मेल खाती है जहां reports फ़ील्ड मौजूद नहीं है या इसका मान null या [] है।

IsEmpty को योग्यता एक योगिक इंकार must_not के साथ उपयोग करते समय बहुत उपयोगी माना जाता है। इस मामले में, यह सभी गैर-रिक्त मानों को चुनेगी।

NULL है

मैच शर्त NULL मानों के लिए परीक्षण नहीं कर सकती। हमें IsNull शर्त का उपयोग करना चाहिए:

{
    "is_null": {
        "key": "reports"
    }
}

यह शर्त उन सभी रिकॉर्ड्स से मेल खाती है जहां reports फ़ील्ड मौजूद है और इसका मान NULL है।

ID है

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

POST /collections/{collection_name}/points/scroll

{
    "filter": {
        "must": [
            { "has_id": [1,3,5,7,9,11] }
        ]
    }
  ...
}

फ़िल्टर किए गए बिंदु होते हैं:

[
  { "id": 1, "city": "लंदन", "रंग": "हरा" },
  { "id": 3, "city": "लंदन", "रंग": "नीला" },
  { "id": 5, "city": "मॉस्को", "रंग": "हरा" }
]