البحث المُصفى باستخدام StructArray

استخدم هذه الصفحة لإضافة تصفية قياسية إلى البحث المتجه في حقول StructArray. تتكون تصفية StructArray من مستويين: تعمل المرشحات على مستوى الصف على تحديد الكيانات الأصلية، بينما تحدد المرشحات على مستوى العنصر عناصر Struct التي تشارك في البحث المتجه على مستوى العنصر.

تستخدم هذه الصفحة المجموعة " tech_articles " من "إنشاء حقل StructArray". تحتوي المجموعة على حقل StructArray باسم " chunks"، مع حقول فرعية قياسية مثل " section" و" page" و" quality_score" و" has_code"، بالإضافة إلى حقول فرعية متجهة للبحث.

قبل تشغيل هذه الأمثلة، قم بإنشاء المجموعة، وإدراج بيانات المثال، وإنشاء الفهارس المتجهة المطلوبة، وتحميل المجموعة. استخدم متجهات رباعية الأبعاد للحقول الموضحة هنا. يفترض كل كتلة كود وجود الاتصال والمتغيرات من الأمثلة السابقة في نفس اللغة ما لم يتم تعريفها مرة أخرى.

اختر نوع المرشح

الهدفالاستخدامسلوك النتيجة
التصفية حسب حقل قياسي من المستوى الأعلى، مثل category.تعبير تصفية عادي.يختار الكيانات الأصلية قبل البحث أو أثناءه.
تقييد البحث المتجهي على مستوى العناصر على عناصر Struct التي تتطابق مع الشروط القياسية.element_filter.يبحث فقط عن عناصر Struct المطابقة ويمكنه إرجاع إزاحات العناصر المطابقة.
تحديد الكيانات بناءً على ما إذا كانت أي عناصر من نوع Struct أو جميعها أو عدد محدد منها تتطابق مع المسند.MATCH_ANY، MATCH_ALL ، MATCH_LEAST ، MATCH_MOST ، أو MATCH_EXACT.التصفية على مستوى الصف. لا تُرجع هذه العوامل إزاحات بحد ذاتها.
اختبار موضع عنصر واحد، أو حساب عدد عناصر Struct، أو التحقق من قيم الحقول الفرعية عبر العناصر دون استخدام $[...].مسارات StructArray على مستوى الصف، مثل chunks[0][section] أو array_length(chunks) أو array_contains(chunks[section], ...).التصفية على مستوى الصف. للاطلاع على قواعد الصياغة، راجع " StructArray Operators".

تشرح هذه الصفحة كيفية استخدام عوامل تصفية StructArray في سير عمل البحث. للاطلاع على قواعد بناء الجملة الكاملة وأنواع المسندات المدعومة ومصفوفة المسندات غير المدعومة، راجع " عوامل StructArray".

التصفية حسب الحقول ذات المستوى الأعلى

استخدم تعبيرات التصفية العادية عندما ينتمي الشرط إلى الكيان الأصلي، وليس إلى عنصر Struct فردي. يعمل هذا مع كل من البحث EmbeddingList والبحث على مستوى العناصر.

from pymilvus import MilvusClient
from pymilvus.client.embedding_list import EmbeddingList

client = MilvusClient(
    uri="http://localhost:19530",
    token="root:Milvus",
)

query = EmbeddingList()
query.add([0.12, 0.21, 0.32, 0.44])
query.add([0.18, 0.23, 0.29, 0.36])

results = client.search(
    collection_name="tech_articles",
    data=[query],
    anns_field="chunks[emb_list_vector]",
    filter='category == "search"',
    limit=3,
    output_fields=[
        "doc_id",
        "title",
        "category",
        "chunks[text]",
        "chunks[section]",
    ],
)
import io.milvus.v2.client.ConnectConfig;
import io.milvus.v2.client.MilvusClientV2;
import io.milvus.v2.service.vector.request.SearchReq;
import io.milvus.v2.service.vector.request.data.EmbeddingList;
import io.milvus.v2.service.vector.request.data.FloatVec;
import io.milvus.v2.service.vector.response.SearchResp;
import java.util.Arrays;
import java.util.Collections;

ConnectConfig connectConfig = ConnectConfig.builder()
        .uri("http://localhost:19530")
        .token("root:Milvus")
        .build();
MilvusClientV2 client = new MilvusClientV2(connectConfig);

EmbeddingList query = new EmbeddingList();
query.add(new FloatVec(Arrays.asList(0.12f, 0.21f, 0.32f, 0.44f)));
query.add(new FloatVec(Arrays.asList(0.18f, 0.23f, 0.29f, 0.36f)));

SearchResp results = client.search(SearchReq.builder()
        .collectionName("tech_articles")
        .data(Collections.singletonList(query))
        .annsField("chunks[emb_list_vector]")
        .filter("category == \"search\"")
        .limit(3)
        .outputFields(Arrays.asList("doc_id", "title", "category", "chunks[text]", "chunks[section]"))
        .build());
import (
    "context"
    "fmt"
    "log"

    "github.com/milvus-io/milvus/client/v3/entity"

    milvusclient "github.com/milvus-io/milvus/client/v3/milvusclient"
)

ctx := context.Background()

cli, err := milvusclient.New(ctx, &milvusclient.ClientConfig{
    Address: "http://localhost:19530",
    APIKey:  "root:Milvus",
})
if err != nil {
    log.Fatal(err)
}

query := entity.FloatVectorArray{
    entity.FloatVector{0.12, 0.21, 0.32, 0.44},
    entity.FloatVector{0.18, 0.23, 0.29, 0.36},
}

results, err := cli.Search(ctx, milvusclient.NewSearchOption("tech_articles", 3, []entity.Vector{query}).
    WithANNSField("chunks[emb_list_vector]").
    WithFilter("category == \"search\"").
    WithOutputFields("doc_id", "title", "category", "chunks[text]", "chunks[section]"))
if err != nil {
    fmt.Println(err.Error())
    return
}
fmt.Printf("returned %d result sets\n", len(results))
use milvus::v2::prelude::*;

let config = ConnectConfig::new().uri("http://localhost:19530").token("root:Milvus");
let client = ClientV2::new(&config).await?;

let query = EmbeddingList::new()
    .add_vector(vec![0.12f32, 0.21, 0.32, 0.44])
    .add_vector(vec![0.18f32, 0.23, 0.29, 0.36]);

let request = SearchRequest::builder()
    .collection_name("tech_articles")
    .vector_field("chunks[emb_list_vector]")
    .vectors(SearchVectors::EmbeddingLists(vec![query]))
    .filter("category == \"search\"")
    .limit(3)
    .output_fields(vec!["doc_id", "title", "category", "chunks[text]", "chunks[section]"])
    .build()?;

let results = client.search(request).await?;
#include <iostream>
#include <memory>

#include "milvus/MilvusClientV2.h"
#include "milvus/request/dql/SearchRequest.h"
#include "milvus/types/EmbeddingList.h"

auto client = milvus::MilvusClientV2::Create();
auto status = client->Connect(milvus::ConnectParam("http://localhost:19530").WithToken("root:Milvus"));
if (!status.IsOk()) {
    std::cout << status.Message() << std::endl;
    return 1;
}

milvus::EmbeddingList query;
query.AddFloatVector({0.12f, 0.21f, 0.32f, 0.44f});
query.AddFloatVector({0.18f, 0.23f, 0.29f, 0.36f});

milvus::SearchRequest request;
request.WithCollectionName("tech_articles")
       .WithAnnsField("chunks[emb_list_vector]")
       .WithLimit(3)
       .WithFilter("category == \"search\"");
request.WithOutputFields({"doc_id", "title", "category", "chunks[text]", "chunks[section]"});
request.AddEmbeddingList(std::move(query));

milvus::SearchResponse response;
status = client->Search(request, response);
if (!status.IsOk()) {
    std::cout << status.Message() << std::endl;
    return 1;
}
import { MilvusClient } from "@zilliz/milvus2-sdk-node";

const client = new MilvusClient({ address: "http://localhost:19530", token: "root:Milvus" });

const query = [
  [0.12, 0.21, 0.32, 0.44],
  [0.18, 0.23, 0.29, 0.36],
];

const results = await client.search({
  collection_name: "tech_articles",
  data: query,
  anns_field: "chunks[emb_list_vector]",
  filter: 'category == "search"',
  limit: 3,
  output_fields: ["doc_id", "title", "category", "chunks[text]", "chunks[section]"],
});
using Milvus.Client.V2;
using Milvus.Client.V2.Requests.Dql;
using Milvus.Client.V2.Types;

using var client = new MilvusClientV2(new ConnectConfig
{
    Uri = "http://localhost:19530",
    ApiKey = "root:Milvus"
});
await client.ConnectAsync();

var query = new EmbeddingList();
query.Add(new ReadOnlyMemory<float>(new[] { 0.12f, 0.21f, 0.32f, 0.44f }));
query.Add(new ReadOnlyMemory<float>(new[] { 0.18f, 0.23f, 0.29f, 0.36f }));

var results = await client.SearchAsync(new SearchReq
{
    CollectionName = "tech_articles",
    VectorFieldName = "chunks[emb_list_vector]",
    EmbeddingLists = new[] { query },
    Limit = 3,
    Parameters = new SearchParameters
    {
        Expression = "category == \"search\"",
        OutputFields = { "doc_id", "title", "category", "chunks[text]", "chunks[section]" }
    }
});
export CLUSTER_ENDPOINT="http://localhost:19530"
export TOKEN="root:Milvus"

curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/entities/search" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
-d '{
    "collectionName": "tech_articles",
    "data": [[[0.12, 0.21, 0.32, 0.44], [0.18, 0.23, 0.29, 0.36]]],
    "annsField": "chunks[emb_list_vector]",
    "filter": "category == \"search\"",
    "limit": 3,
    "outputFields": ["doc_id", "title", "category", "chunks[text]", "chunks[section]"]
}'

يعمل التصفية أعلاه على اختيار الكيانات التي يكون حقل « category » من المستوى الأعلى فيها هو « "search" » فقط. ولا يحدد عنصر Struct واحدًا مطابقًا.

استخدم element_filter(structArrayField, predicate) عندما يجب أن تنطبق الشروط القياسية على نفس عنصر Struct الذي يشارك في البحث المتجهي على مستوى العنصر. داخل المسند، استخدم $[subfield] للإشارة إلى الحقول الفرعية القياسية لعنصر Struct الحالي.

query_vector = [0.19, 0.24, 0.30, 0.37]

filter_expr = (
    'category == "search" && '
    'element_filter(chunks, '
    '$[section] == "index" && '
    '$[quality_score] > 0.9 && '
    '$[has_code] == true)'
)

results = client.search(
    collection_name="tech_articles",
    data=[query_vector],
    anns_field="chunks[emb]",
    filter=filter_expr,
    limit=5,
    output_fields=[
        "doc_id",
        "title",
        "chunks[text]",
        "chunks[section]",
        "chunks[page]",
        "chunks[quality_score]",
        "chunks[has_code]",
    ],
)

for hits in results:
    for hit in hits:
        print(
            "doc_id:", hit["doc_id"],
            "distance:", hit["distance"],
            "offset:", hit.get("offset"),
            "entity:", hit["entity"],
        )
import io.milvus.v2.client.ConnectConfig;
import io.milvus.v2.client.MilvusClientV2;
import io.milvus.v2.service.vector.request.SearchReq;
import io.milvus.v2.service.vector.request.data.FloatVec;
import io.milvus.v2.service.vector.response.SearchResp;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

ConnectConfig connectConfig = ConnectConfig.builder()
        .uri("http://localhost:19530")
        .token("root:Milvus")
        .build();
MilvusClientV2 client = new MilvusClientV2(connectConfig);

FloatVec queryVector = new FloatVec(Arrays.asList(0.19f, 0.24f, 0.30f, 0.37f));

String filterExpr = "category == \"search\" && element_filter(chunks, $[section] == \"index\" && $[quality_score] > 0.9 && $[has_code] == true)";

SearchResp results = client.search(SearchReq.builder()
        .collectionName("tech_articles")
        .data(Collections.singletonList(queryVector))
        .annsField("chunks[emb]")
        .filter(filterExpr)
        .limit(5)
        .outputFields(Arrays.asList("doc_id", "title", "chunks[text]", "chunks[section]", "chunks[page]", "chunks[quality_score]", "chunks[has_code]"))
        .build());

for (List<SearchResp.SearchResult> hits : results.getSearchResults()) {
    for (SearchResp.SearchResult hit : hits) {
        System.out.println("doc_id: " + hit.getId() + ", distance: " + hit.getScore()
                + ", offset: " + hit.getElementOffset() + ", entity: " + hit.getEntity());
    }
}
import (
    "context"
    "fmt"
    "log"

    "github.com/milvus-io/milvus/client/v3/entity"

    milvusclient "github.com/milvus-io/milvus/client/v3/milvusclient"
)

ctx := context.Background()

cli, err := milvusclient.New(ctx, &milvusclient.ClientConfig{
    Address: "http://localhost:19530",
    APIKey:  "root:Milvus",
})
if err != nil {
    log.Fatal(err)
}

queryVector := entity.FloatVector{0.19, 0.24, 0.30, 0.37}

filterExpr := "category == \"search\" && element_filter(chunks, $[section] == \"index\" && $[quality_score] > 0.9 && $[has_code] == true)"

results, err := cli.Search(ctx, milvusclient.NewSearchOption("tech_articles", 5, []entity.Vector{queryVector}).
    WithANNSField("chunks[emb]").
    WithFilter(filterExpr).
    WithOutputFields("doc_id", "title", "chunks[text]", "chunks[section]", "chunks[page]", "chunks[quality_score]", "chunks[has_code]"))
if err != nil {
    fmt.Println(err.Error())
    return
}
fmt.Printf("returned %d result sets\n", len(results))
use milvus::v2::prelude::*;

let config = ConnectConfig::new().uri("http://localhost:19530").token("root:Milvus");
let client = ClientV2::new(&config).await?;

let query_vector = vec![0.19f32, 0.24, 0.30, 0.37];

let filter_expr = "category == \"search\" && element_filter(chunks, $[section] == \"index\" && $[quality_score] > 0.9 && $[has_code] == true)";

let request = SearchRequest::builder()
    .collection_name("tech_articles")
    .vector_field("chunks[emb]")
    .vectors(SearchVectors::Float(vec![query_vector]))
    .filter(filter_expr)
    .limit(5)
    .output_fields(vec!["doc_id", "title", "chunks[text]", "chunks[section]", "chunks[page]", "chunks[quality_score]", "chunks[has_code]"])
    .build()?;

let results = client.search(request).await?;
#include <iostream>
#include <memory>
#include <vector>

#include "milvus/MilvusClientV2.h"
#include "milvus/request/dql/SearchRequest.h"

auto client = milvus::MilvusClientV2::Create();
auto status = client->Connect(milvus::ConnectParam("http://localhost:19530").WithToken("root:Milvus"));
if (!status.IsOk()) {
    std::cout << status.Message() << std::endl;
    return 1;
}

std::vector<float> query_vector = {0.19f, 0.24f, 0.30f, 0.37f};

milvus::SearchRequest request;
request.WithCollectionName("tech_articles")
       .WithAnnsField("chunks[emb]")
       .WithLimit(5)
       .WithFilter("category == \"search\" && element_filter(chunks, $[section] == \"index\" && $[quality_score] > 0.9 && $[has_code] == true)");
request.WithOutputFields({"doc_id", "title", "chunks[text]", "chunks[section]", "chunks[page]", "chunks[quality_score]", "chunks[has_code]"});
request.AddFloatVector(query_vector);

milvus::SearchResponse response;
status = client->Search(request, response);
if (!status.IsOk()) {
    std::cout << status.Message() << std::endl;
    return 1;
}
const query_vector = [0.19, 0.24, 0.30, 0.37];

const filter_expr = 'category == "search" && element_filter(chunks, $[section] == "index" && $[quality_score] > 0.9 && $[has_code] == true)';

const results = await client.search({
  collection_name: "tech_articles",
  data: query_vector,
  anns_field: "chunks[emb]",
  filter: filter_expr,
  limit: 5,
  output_fields: ["doc_id", "title", "chunks[text]", "chunks[section]", "chunks[page]", "chunks[quality_score]", "chunks[has_code]"],
});
using Milvus.Client.V2.Requests.Dql;
using Milvus.Client.V2.Types;

var queryVector = new ReadOnlyMemory<float>(new[] { 0.19f, 0.24f, 0.30f, 0.37f });

var filterExpr = "category == \"search\" && " +
    "element_filter(chunks, " +
    "$[section] == \"index\" && " +
    "$[quality_score] > 0.9 && " +
    "$[has_code] == true)";

var results = await client.SearchAsync(new SearchReq
{
    CollectionName = "tech_articles",
    VectorFieldName = "chunks[emb]",
    Vectors = new[] { queryVector },
    Limit = 5,
    Parameters = new SearchParameters
    {
        Expression = filterExpr,
        OutputFields = { "doc_id", "title", "chunks[text]", "chunks[section]", "chunks[page]", "chunks[quality_score]", "chunks[has_code]" }
    }
});
export CLUSTER_ENDPOINT="http://localhost:19530"
export TOKEN="root:Milvus"

curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/entities/search" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
-d '{
    "collectionName": "tech_articles",
    "data": [[0.19, 0.24, 0.30, 0.37]],
    "annsField": "chunks[emb]",
    "filter": "category == \"search\" && element_filter(chunks, $[section] == \"index\" && $[quality_score] > 0.9 && $[has_code] == true)",
    "limit": 5,
    "outputFields": ["doc_id", "title", "chunks[text]", "chunks[section]", "chunks[page]", "chunks[quality_score]", "chunks[has_code]"]
}'

في هذا المثال، يقوم المسند ذو المستوى الأعلى category == "search" باختيار الكيانات المرشحة، ويقوم element_filter بتقييد البحث المتجهي على مستوى العناصر ليقتصر على المجموعات التي تتطابق فيها section و quality_score و has_code جميعها في نفس عنصر Struct.

تحذير

عند دمج مسند من المستوى الأعلى مع element_filter ، ضع element_filter في نهاية التعبير. لا يمكن أن يحتوي تعبير التصفية إلا على element_filter واحد فقط، ولا يمكنك تضمين element_filter أو MATCH_* داخل عامل StructArray آخر.

تصفية الكيانات باستخدام عوامل التشغيل MATCH

استخدم مشغلات MATCH_* عندما يتعين على التصفية تحديد ما إذا كانت الكيانات الأصلية مؤهلة بناءً على عناصر Struct الخاصة بها. هذه المشغلات هي عوامل تصفية على مستوى الصف: فهي تحدد الكيانات، ولكنها لا تُرجع إزاحات العناصر بنفسها.

المشغلاستخدمه عندمامثال
MATCH_ANYيجب أن يستوفي عنصر Struct واحد على الأقل الشرط.MATCH_ANY(chunks, $[section] == "index")
MATCH_ALLيجب أن تستوفي جميع عناصر Struct الشرط.MATCH_ALL(chunks, $[quality_score] > 0.5)
MATCH_LEASTيجب أن تستوفي عناصر Struct التي لا يقل عددها عن N الشرط.MATCH_LEAST(chunks, $[has_code] == true, threshold=2)
MATCH_MOSTيجب أن تستوفي عناصر Struct التي لا يتجاوز عددها N الشرط.MATCH_MOST(chunks, $[section] == "appendix", threshold=1)
MATCH_EXACTيجب أن تستوفي عناصر Struct التي يبلغ عددها بالضبط N الشرط.MATCH_EXACT(chunks, $[section] == "summary", threshold=1)
from pymilvus.client.embedding_list import EmbeddingList

query = EmbeddingList()
query.add([0.12, 0.21, 0.32, 0.44])
query.add([0.18, 0.23, 0.29, 0.36])

filter_expr = (
    'category == "search" && '
    'MATCH_ANY(chunks, $[section] == "index" && $[quality_score] > 0.9)'
)

results = client.search(
    collection_name="tech_articles",
    data=[query],
    anns_field="chunks[emb_list_vector]",
    filter=filter_expr,
    limit=3,
    output_fields=[
        "doc_id",
        "title",
        "category",
        "chunks[text]",
        "chunks[section]",
        "chunks[quality_score]",
    ],
)
import io.milvus.v2.client.ConnectConfig;
import io.milvus.v2.client.MilvusClientV2;
import io.milvus.v2.service.vector.request.SearchReq;
import io.milvus.v2.service.vector.request.data.EmbeddingList;
import io.milvus.v2.service.vector.request.data.FloatVec;
import io.milvus.v2.service.vector.response.SearchResp;
import java.util.Arrays;
import java.util.Collections;

ConnectConfig connectConfig = ConnectConfig.builder()
        .uri("http://localhost:19530")
        .token("root:Milvus")
        .build();
MilvusClientV2 client = new MilvusClientV2(connectConfig);

EmbeddingList query = new EmbeddingList();
query.add(new FloatVec(Arrays.asList(0.12f, 0.21f, 0.32f, 0.44f)));
query.add(new FloatVec(Arrays.asList(0.18f, 0.23f, 0.29f, 0.36f)));

String filterExpr = "category == \"search\" && MATCH_ANY(chunks, $[section] == \"index\" && $[quality_score] > 0.9)";

SearchResp results = client.search(SearchReq.builder()
        .collectionName("tech_articles")
        .data(Collections.singletonList(query))
        .annsField("chunks[emb_list_vector]")
        .filter(filterExpr)
        .limit(3)
        .outputFields(Arrays.asList("doc_id", "title", "category", "chunks[text]", "chunks[section]", "chunks[quality_score]"))
        .build());
import (
    "context"
    "fmt"
    "log"

    "github.com/milvus-io/milvus/client/v3/entity"

    milvusclient "github.com/milvus-io/milvus/client/v3/milvusclient"
)

ctx := context.Background()

cli, err := milvusclient.New(ctx, &milvusclient.ClientConfig{
    Address: "http://localhost:19530",
    APIKey:  "root:Milvus",
})
if err != nil {
    log.Fatal(err)
}

query := entity.FloatVectorArray{
    entity.FloatVector{0.12, 0.21, 0.32, 0.44},
    entity.FloatVector{0.18, 0.23, 0.29, 0.36},
}

filterExpr := "category == \"search\" && MATCH_ANY(chunks, $[section] == \"index\" && $[quality_score] > 0.9)"

results, err := cli.Search(ctx, milvusclient.NewSearchOption("tech_articles", 3, []entity.Vector{query}).
    WithANNSField("chunks[emb_list_vector]").
    WithFilter(filterExpr).
    WithOutputFields("doc_id", "title", "category", "chunks[text]", "chunks[section]", "chunks[quality_score]"))
if err != nil {
    fmt.Println(err.Error())
    return
}
fmt.Printf("returned %d result sets\n", len(results))
use milvus::v2::prelude::*;

let config = ConnectConfig::new().uri("http://localhost:19530").token("root:Milvus");
let client = ClientV2::new(&config).await?;

let query = EmbeddingList::new()
    .add_vector(vec![0.12f32, 0.21, 0.32, 0.44])
    .add_vector(vec![0.18f32, 0.23, 0.29, 0.36]);

let filter_expr = "category == \"search\" && MATCH_ANY(chunks, $[section] == \"index\" && $[quality_score] > 0.9)";

let request = SearchRequest::builder()
    .collection_name("tech_articles")
    .vector_field("chunks[emb_list_vector]")
    .vectors(SearchVectors::EmbeddingLists(vec![query]))
    .filter(filter_expr)
    .limit(3)
    .output_fields(vec!["doc_id", "title", "category", "chunks[text]", "chunks[section]", "chunks[quality_score]"])
    .build()?;

let results = client.search(request).await?;
#include <iostream>
#include <memory>

#include "milvus/MilvusClientV2.h"
#include "milvus/request/dql/SearchRequest.h"
#include "milvus/types/EmbeddingList.h"

auto client = milvus::MilvusClientV2::Create();
auto status = client->Connect(milvus::ConnectParam("http://localhost:19530").WithToken("root:Milvus"));
if (!status.IsOk()) {
    std::cout << status.Message() << std::endl;
    return 1;
}

milvus::EmbeddingList query;
query.AddFloatVector({0.12f, 0.21f, 0.32f, 0.44f});
query.AddFloatVector({0.18f, 0.23f, 0.29f, 0.36f});

milvus::SearchRequest request;
request.WithCollectionName("tech_articles")
       .WithAnnsField("chunks[emb_list_vector]")
       .WithLimit(3)
       .WithFilter("category == \"search\" && MATCH_ANY(chunks, $[section] == \"index\" && $[quality_score] > 0.9)");
request.WithOutputFields({"doc_id", "title", "category", "chunks[text]", "chunks[section]", "chunks[quality_score]"});
request.AddEmbeddingList(std::move(query));

milvus::SearchResponse response;
status = client->Search(request, response);
if (!status.IsOk()) {
    std::cout << status.Message() << std::endl;
    return 1;
}
const query = [
  [0.12, 0.21, 0.32, 0.44],
  [0.18, 0.23, 0.29, 0.36],
];

const filter_expr = 'category == "search" && MATCH_ANY(chunks, $[section] == "index" && $[quality_score] > 0.9)';

const results = await client.search({
  collection_name: "tech_articles",
  data: query,
  anns_field: "chunks[emb_list_vector]",
  filter: filter_expr,
  limit: 3,
  output_fields: ["doc_id", "title", "category", "chunks[text]", "chunks[section]", "chunks[quality_score]"],
});
using Milvus.Client.V2.Requests.Dql;
using Milvus.Client.V2.Types;

var query = new EmbeddingList();
query.Add(new ReadOnlyMemory<float>(new[] { 0.12f, 0.21f, 0.32f, 0.44f }));
query.Add(new ReadOnlyMemory<float>(new[] { 0.18f, 0.23f, 0.29f, 0.36f }));

var filterExpr = "category == \"search\" && " +
    "MATCH_ANY(chunks, $[section] == \"index\" && $[quality_score] > 0.9)";

var results = await client.SearchAsync(new SearchReq
{
    CollectionName = "tech_articles",
    VectorFieldName = "chunks[emb_list_vector]",
    EmbeddingLists = new[] { query },
    Limit = 3,
    Parameters = new SearchParameters
    {
        Expression = filterExpr,
        OutputFields = { "doc_id", "title", "category", "chunks[text]", "chunks[section]", "chunks[quality_score]" }
    }
});
export CLUSTER_ENDPOINT="http://localhost:19530"
export TOKEN="root:Milvus"

curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/entities/search" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
-d '{
    "collectionName": "tech_articles",
    "data": [[[0.12, 0.21, 0.32, 0.44], [0.18, 0.23, 0.29, 0.36]]],
    "annsField": "chunks[emb_list_vector]",
    "filter": "category == \"search\" && MATCH_ANY(chunks, $[section] == \"index\" && $[quality_score] > 0.9)",
    "limit": 3,
    "outputFields": ["doc_id", "title", "category", "chunks[text]", "chunks[section]", "chunks[quality_score]"]
}'

استخدم " MATCH_ANY " هنا لأن نتيجة البحث في EmbeddingList تكون على مستوى الكيان. يتطلب المرشح أن تكون هناك قطعة واحدة على الأقل في الكيان من نوع " "index" " ذات جودة عالية، لكن نتيجة البحث نفسها لا تزال تمثل الكيان الأصلي.

في البحث المختلط، قم بتطبيق مرشحات StructArray حيث يجب أن يسري الشرط. قم بتطبيق شرط الكيان الأصلي على كل طلب فرعي يجب أن يستوفيه. قم بإرفاق element_filter فقط بالطلب على مستوى عنصر StructArray الذي يحتاج إلى قيود على مستوى العنصر، بعد شرط الكيان الأصلي.

from pymilvus import AnnSearchRequest, RRFRanker

query_vector = [0.19, 0.24, 0.30, 0.37]

title_req = AnnSearchRequest(
    data=[query_vector],
    anns_field="title_vector",
    param={},
    limit=10,
    expr='category == "search"',
)

chunk_req = AnnSearchRequest(
    data=[query_vector],
    anns_field="chunks[emb]",
    param={},
    limit=10,
    expr='category == "search" && element_filter(chunks, $[section] == "index" && $[quality_score] > 0.9)',
)

results = client.hybrid_search(
    collection_name="tech_articles",
    reqs=[title_req, chunk_req],
    ranker=RRFRanker(),
    limit=5,
    output_fields=[
        "doc_id",
        "title",
        "category",
        "chunks[text]",
        "chunks[section]",
        "chunks[quality_score]",
    ],
)
import io.milvus.v2.client.ConnectConfig;
import io.milvus.v2.client.MilvusClientV2;
import io.milvus.v2.service.vector.request.AnnSearchReq;
import io.milvus.v2.service.vector.request.HybridSearchReq;
import io.milvus.v2.service.vector.request.data.FloatVec;
import io.milvus.v2.service.vector.request.ranker.RRFRanker;
import io.milvus.v2.service.vector.response.SearchResp;
import java.util.Arrays;
import java.util.Collections;

ConnectConfig connectConfig = ConnectConfig.builder()
        .uri("http://localhost:19530")
        .token("root:Milvus")
        .build();
MilvusClientV2 client = new MilvusClientV2(connectConfig);

FloatVec queryVector = new FloatVec(Arrays.asList(0.19f, 0.24f, 0.30f, 0.37f));

AnnSearchReq titleReq = AnnSearchReq.builder()
        .vectorFieldName("title_vector")
        .vectors(Collections.singletonList(queryVector))
        .limit(10)
        .filter("category == \"search\"")
        .build();

AnnSearchReq chunkReq = AnnSearchReq.builder()
        .vectorFieldName("chunks[emb]")
        .vectors(Collections.singletonList(queryVector))
        .limit(10)
        .filter("category == \"search\" && element_filter(chunks, $[section] == \"index\" && $[quality_score] > 0.9)")
        .build();

SearchResp results = client.hybridSearch(HybridSearchReq.builder()
        .collectionName("tech_articles")
        .searchRequests(Arrays.asList(titleReq, chunkReq))
        .ranker(RRFRanker.builder().k(60).build())
        .limit(5)
        .outFields(Arrays.asList("doc_id", "title", "category", "chunks[text]", "chunks[section]", "chunks[quality_score]"))
        .build());
import (
    "context"
    "fmt"
    "log"

    "github.com/milvus-io/milvus/client/v3/entity"

    milvusclient "github.com/milvus-io/milvus/client/v3/milvusclient"
)

ctx := context.Background()

cli, err := milvusclient.New(ctx, &milvusclient.ClientConfig{
    Address: "http://localhost:19530",
    APIKey:  "root:Milvus",
})
if err != nil {
    log.Fatal(err)
}

queryVector := entity.FloatVector{0.19, 0.24, 0.30, 0.37}

titleReq := milvusclient.NewAnnRequest("title_vector", 10, queryVector).
    WithFilter("category == \"search\"")
chunkReq := milvusclient.NewAnnRequest("chunks[emb]", 10, queryVector).
    WithFilter("category == \"search\" && element_filter(chunks, $[section] == \"index\" && $[quality_score] > 0.9)")

results, err := cli.HybridSearch(ctx, milvusclient.NewHybridSearchOption("tech_articles", 5,
    titleReq, chunkReq).
    WithReranker(milvusclient.NewRRFReranker()).
    WithOutputFields("doc_id", "title", "category", "chunks[text]", "chunks[section]", "chunks[quality_score]"))
if err != nil {
    fmt.Println(err.Error())
    return
}
fmt.Printf("returned %d result sets\n", len(results))
use milvus::v2::prelude::*;

let config = ConnectConfig::new().uri("http://localhost:19530").token("root:Milvus");
let client = ClientV2::new(&config).await?;

let query_vector = vec![0.19f32, 0.24, 0.30, 0.37];

let title_req = SubSearchRequest::builder()
    .vector_field("title_vector")
    .vectors(SearchVectors::Float(vec![query_vector.clone()]))
    .limit(10)
    .filter("category == \"search\"")
    .build()?;

let chunk_req = SubSearchRequest::builder()
    .vector_field("chunks[emb]")
    .vectors(SearchVectors::Float(vec![query_vector]))
    .limit(10)
    .filter("category == \"search\" && element_filter(chunks, $[section] == \"index\" && $[quality_score] > 0.9)")
    .build()?;

let request = HybridSearchRequest::builder()
    .collection_name("tech_articles")
    .sub_requests(vec![title_req, chunk_req])
    .rerank(RRFRerank::new().k(60))
    .limit(5)
    .output_fields(vec!["doc_id", "title", "category", "chunks[text]", "chunks[section]", "chunks[quality_score]"])
    .build()?;

let results = client.hybrid_search(request).await?;
#include <iostream>
#include <memory>
#include <vector>

#include "milvus/MilvusClientV2.h"
#include "milvus/request/dql/HybridSearchRequest.h"
#include "milvus/types/SubSearchRequest.h"

auto client = milvus::MilvusClientV2::Create();
auto status = client->Connect(milvus::ConnectParam("http://localhost:19530").WithToken("root:Milvus"));
if (!status.IsOk()) {
    std::cout << status.Message() << std::endl;
    return 1;
}

std::vector<float> query_vector = {0.19f, 0.24f, 0.30f, 0.37f};

auto title_req = std::make_shared<milvus::SubSearchRequest>();
title_req->WithAnnsField("title_vector").WithLimit(10);
title_req->WithFilter("category == \"search\"");
title_req->AddFloatVector(query_vector);

auto chunk_req = std::make_shared<milvus::SubSearchRequest>();
chunk_req->WithAnnsField("chunks[emb]").WithLimit(10);
chunk_req->WithFilter("category == \"search\" && element_filter(chunks, $[section] == \"index\" && $[quality_score] > 0.9)");
chunk_req->AddFloatVector(query_vector);

milvus::HybridSearchRequest request;
request.WithCollectionName("tech_articles")
       .WithLimit(5)
       .AddSubRequest(title_req)
       .AddSubRequest(chunk_req)
       .WithRerank(std::make_shared<milvus::RRFRerank>(60));
request.WithOutputFields({"doc_id", "title", "category", "chunks[text]", "chunks[section]", "chunks[quality_score]"});

milvus::HybridSearchResponse response;
status = client->HybridSearch(request, response);
if (!status.IsOk()) {
    std::cout << status.Message() << std::endl;
    return 1;
}
const query_vector = [0.19, 0.24, 0.30, 0.37];

const results = await client.search({
  collection_name: "tech_articles",
  data: [
    { anns_field: "title_vector", data: [query_vector], limit: 10, expr: 'category == "search"' },
    {
      anns_field: "chunks[emb]",
      data: query_vector,
      limit: 10,
      expr: 'category == "search" && element_filter(chunks, $[section] == "index" && $[quality_score] > 0.9)',
    },
  ],
  rerank: { strategy: "rrf", params: { k: 60 } },
  limit: 5,
  output_fields: ["doc_id", "title", "category", "chunks[text]", "chunks[section]", "chunks[quality_score]"],
});
using Milvus.Client.V2.Requests.Dql;
using Milvus.Client.V2.Types;

var queryVector = new ReadOnlyMemory<float>(new[] { 0.19f, 0.24f, 0.30f, 0.37f });

var titleReq = new AnnSearchReq
{
    VectorFieldName = "title_vector",
    Vectors = new[] { queryVector },
    Limit = 10,
    Expression = "category == \"search\""
};

var chunkReq = new AnnSearchReq
{
    VectorFieldName = "chunks[emb]",
    Vectors = new[] { queryVector },
    Limit = 10,
    Expression = "category == \"search\" && element_filter(chunks, $[section] == \"index\" && $[quality_score] > 0.9)"
};

var results = await client.HybridSearchAsync(new HybridSearchReq
{
    CollectionName = "tech_articles",
    SearchRequests = new[] { titleReq, chunkReq },
    Reranker = new RrfReranker(60),
    Limit = 5,
    Parameters = new SearchParameters
    {
        OutputFields = { "doc_id", "title", "category", "chunks[text]", "chunks[section]", "chunks[quality_score]" }
    }
});
export CLUSTER_ENDPOINT="http://localhost:19530"
export TOKEN="root:Milvus"

curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/entities/hybrid_search" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
-d '{
    "collectionName": "tech_articles",
    "search": [
        {
            "data": [[0.19, 0.24, 0.30, 0.37]],
            "annsField": "title_vector",
            "limit": 10,
            "filter": "category == \"search\""
        },
        {
            "data": [[0.19, 0.24, 0.30, 0.37]],
            "annsField": "chunks[emb]",
            "limit": 10,
            "filter": "category == \"search\" && element_filter(chunks, $[section] == \"index\" && $[quality_score] > 0.9)"
        }
    ],
    "rerank": { "strategy": "rrf", "params": { "k": 60 } },
    "limit": 5,
    "outputFields": ["doc_id", "title", "category", "chunks[text]", "chunks[section]", "chunks[quality_score]"]
}'

يطبق كلا الطلبين الفرعيين category == "search". كما يفرض التعبير chunk_req قيودًا على عناصر Struct التي تشارك في البحث المتجه الخاص به. للاطلاع على تركيبات البحث الهجين المدعومة والحدود الخاصة بكل إصدار، راجع البحث الهجين باستخدام StructArray وحدود StructArray.

ملخص دعم المسندات

استخدم الحقول الفرعية القياسية في شروط StructArray. لا تُعتبر الحقول الفرعية المتجهة مدخلات قياسية للشروط.

نوع الحقل الفرعيأمثلة نموذجية على المسندات
BOOL$[has_code] == true، !($[has_code] == true)
أنواع الأعداد الصحيحة$[page] >= 2، $[page] in [1, 2, 3]
FLOAT، DOUBLE$[quality_score] > 0.9، 0.7 < $[quality_score] < 0.95
VARCHAR$[section] == "index"، $[text] like "range%"
الحقول الفرعية للمتجهاتغير مدعومة كمدخلات للمسندات القياسية في $[...]. استخدم الحقول الفرعية للمتجهات من خلال البحث المتجهي بدلاً من ذلك.

بالنسبة للحالات غير المدعومة مثل مسارات JSON، ووظائف حاويات المصفوفات، ووظائف مطابقة النص، والمسندات ذات القيمة null في $[...] ، ووظائف Geometry، وتعبيرات Timestamptz، واستدعاءات الوظائف العامة، راجع StructArray Operators.

الأخطاء الشائعة

  • استخدام $[subfield] خارج element_filter أو MATCH_*.

  • استخدام chunks.section بدلاً من صيغة مشغل StructArray مثل element_filter(chunks, $[section] == "index").

  • استخدام element_filter عندما تحتاج فقط إلى التصفية على مستوى الصفوف. استخدم MATCH_ANY بدلاً من ذلك إذا كنت تحتاج فقط إلى تحديد الكيانات.

  • توقع أن تُرجع MATCH_* إزاحات العناصر. تختار هذه العوامل الكيانات ولا تحدد عنصرًا مطابقًا واحدًا بمفردها.

  • كتابة المسندات المنطقية المجردة مثل $[has_code]. استخدم مقارنات صريحة مثل $[has_code] == true.

  • وضع element_filter قبل مسند من المستوى الأعلى في نفس تعبير التصفية.

الخطوات التالية

  1. لمراجعة صيغة تصفية StructArray الكاملة، اقرأ «مشغلات StructArray».

  2. لتشغيل عمليات البحث المتجهية غير المفلترة أولاً، اقرأ البحث المتجهي الأساسي باستخدام StructArray.

  3. لإنشاء فهارس قياسية لمرشحات StructArray المستخدمة بشكل متكرر، اقرأ " فهرسة حقول StructArray".

  4. للتحقق من حدود التصفية والبحث الخاصة بكل إصدار، اقرأ " حدود StructArray".