Фильтрация#

С помощью Platform V Vector DB (далее - Vector DB) можно устанавливать условия при поиске или извлечении точек. Например, можно наложить ограничения как на полезную нагрузку, так и на id точки.

Установка дополнительных условий важна, когда невозможно выразить все характеристики объекта в виде вложения. Примеры включают различные бизнес требования: наличие товара на складе, местоположение пользователя или желаемый диапазон цен.

Операторы фильтрации#

Vector DB позволяет объединять условия в операторах. Операторы представляют собой разные логические операции, такие как OR, AND, и NOT. Операторы могут рекурсивно вкладываться друг в друга таким образом, чтобы можно было воспроизвести произвольное логическое выражение.

В качестве примера используется набора точек с полезной нагрузкой:

[
  { "id": 1, "city": "London", "color": "green" },
  { "id": 2, "city": "London", "color": "red" },
  { "id": 3, "city": "London", "color": "blue" },
  { "id": 4, "city": "Berlin", "color": "red" },
  { "id": 5, "city": "Moscow", "color": "green" },
  { "id": 6, "city": "Moscow", "color": "blue" }
]

Оператор Must#

Пример:

POST /collections/{collection_name}/points/scroll
{
    "filter": {
        "must": [
            { "key": "city", "match": { "value": "London" } },
            { "key": "color", "match": { "value": "red" } }
        ]
    }
    ...
}

from qdrant_client import QdrantClient, models

client = QdrantClient(url="http://localhost:6333")

client.scroll(
    collection_name="{collection_name}",
    scroll_filter=models.Filter(
        must=[
            models.FieldCondition(
                key="city",
                match=models.MatchValue(value="London"),
            ),
            models.FieldCondition(
                key="color",
                match=models.MatchValue(value="red"),
            ),
        ]
    ),
)

import { QdrantClient } from "@qdrant/js-client-rest";

const client = new QdrantClient({ host: "localhost", port: 6333 });

client.scroll("{collection_name}", {
  filter: {
    must: [
      {
        key: "city",
        match: { value: "London" },
      },
      {
        key: "color",
        match: { value: "red" },
      },
    ],
  },
});

use qdrant_client::qdrant::{Condition, Filter, ScrollPointsBuilder};
use qdrant_client::Qdrant;

let client = Qdrant::from_url("http://localhost:6334").build()?;

client
    .scroll(
        ScrollPointsBuilder::new("{collection_name}").filter(Filter::must([
            Condition::matches("city", "london".to_string()),
            Condition::matches("color", "red".to_string()),
        ])),
    )
    .await?;

import java.util.List;

import static io.qdrant.client.ConditionFactory.matchKeyword;

import io.qdrant.client.QdrantClient;
import io.qdrant.client.QdrantGrpcClient;
import io.qdrant.client.grpc.Points.Filter;
import io.qdrant.client.grpc.Points.ScrollPoints;

QdrantClient client =
    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());

client
    .scrollAsync(
        ScrollPoints.newBuilder()
            .setCollectionName("{collection_name}")
            .setFilter(
                Filter.newBuilder()
                    .addAllMust(
                        List.of(matchKeyword("city", "London"), matchKeyword("color", "red")))
                    .build())
            .build())
    .get();

using Qdrant.Client;
using static Qdrant.Client.Grpc.Conditions;

var client = new QdrantClient("localhost", 6334);

// & operator combines two conditions in an AND conjunction(must)
await client.ScrollAsync(
  collectionName: "{collection_name}",
  filter: MatchKeyword("city", "London") & MatchKeyword("color", "red")
);

import (
  "context"

  "github.com/qdrant/go-client/qdrant"
)

client, err := qdrant.NewClient(&qdrant.Config{
  Host: "localhost",
  Port: 6334,
})

client.Scroll(context.Background(), &qdrant.ScrollPoints{
  CollectionName: "{collection_name}",
  Filter: &qdrant.Filter{
      Must: []*qdrant.Condition{
          qdrant.NewMatch("city", "London"),
          qdrant.NewMatch("color", "red"),
      },
  },
})

Результатом фильтрации будут точки:

[{ "id": 2, "city": "London", "color": "red" }]

При использовании must предложение становится true только если выполнены все условия, перечисленные внутри must. В этом смысле must эквивалентен оператору AND.

Оператор Should#

Пример:

POST /collections/{collection_name}/points/scroll
{
    "filter": {
        "should": [
            { "key": "city", "match": { "value": "London" } },
            { "key": "color", "match": { "value": "red" } }
        ]
    }
}

client.scroll(
    collection_name="{collection_name}",
    scroll_filter=models.Filter(
        should=[
            models.FieldCondition(
                key="city",
                match=models.MatchValue(value="London"),
            ),
            models.FieldCondition(
                key="color",
                match=models.MatchValue(value="red"),
            ),
        ]
    ),
)

client.scroll("{collection_name}", {
  filter: {
    should: [
      {
        key: "city",
        match: { value: "London" },
      },
      {
        key: "color",
        match: { value: "red" },
      },
    ],
  },
});

use qdrant_client::qdrant::{Condition, Filter, ScrollPointsBuilder};
use qdrant_client::Qdrant;

let client = Qdrant::from_url("http://localhost:6334").build()?;

client
    .scroll(
        ScrollPointsBuilder::new("{collection_name}").filter(Filter::should([
            Condition::matches("city", "london".to_string()),
            Condition::matches("color", "red".to_string()),
        ])),
    )
    .await?;

import static io.qdrant.client.ConditionFactory.matchKeyword;

import io.qdrant.client.grpc.Points.Filter;
import io.qdrant.client.grpc.Points.ScrollPoints;
import java.util.List;

client
    .scrollAsync(
        ScrollPoints.newBuilder()
            .setCollectionName("{collection_name}")
            .setFilter(
                Filter.newBuilder()
                    .addAllShould(
                        List.of(matchKeyword("city", "London"), matchKeyword("color", "red")))
                    .build())
            .build())
    .get();

using Qdrant.Client;
using static Qdrant.Client.Grpc.Conditions;

var client = new QdrantClient("localhost", 6334);

// | operator combines two conditions in an OR disjunction(should)
await client.ScrollAsync(
  collectionName: "{collection_name}",
  filter: MatchKeyword("city", "London") | MatchKeyword("color", "red")
);

import (
  "context"

  "github.com/qdrant/go-client/qdrant"
)

client, err := qdrant.NewClient(&qdrant.Config{
  Host: "localhost",
  Port: 6334,
})

client.Scroll(context.Background(), &qdrant.ScrollPoints{
  CollectionName: "{collection_name}",
  Filter: &qdrant.Filter{
      Should: []*qdrant.Condition{
          qdrant.NewMatch("city", "London"),
          qdrant.NewMatch("color", "red"),
      },
  },
})

Результатом фильтрации будут точки:

[
  { "id": 1, "city": "London", "color": "green" },
  { "id": 2, "city": "London", "color": "red" },
  { "id": 3, "city": "London", "color": "blue" },
  { "id": 4, "city": "Berlin", "color": "red" }
]

При использовании should предложение становится true, если хотя бы одно из условий, перечисленных внутри should, выполнено. В этом смысле should эквивалентен оператору OR.

Оператор Must Not#

Пример:

POST /collections/{collection_name}/points/scroll
{
    "filter": {
        "must_not": [
            { "key": "city", "match": { "value": "London" } },
            { "key": "color", "match": { "value": "red" } }
        ]
    }
}

client.scroll(
    collection_name="{collection_name}",
    scroll_filter=models.Filter(
        must_not=[
            models.FieldCondition(key="city", match=models.MatchValue(value="London")),
            models.FieldCondition(key="color", match=models.MatchValue(value="red")),
        ]
    ),
)

client.scroll("{collection_name}", {
  filter: {
    must_not: [
      {
        key: "city",
        match: { value: "London" },
      },
      {
        key: "color",
        match: { value: "red" },
      },
    ],
  },
});

use qdrant_client::qdrant::{Condition, Filter, ScrollPointsBuilder};
use qdrant_client::Qdrant;

let client = Qdrant::from_url("http://localhost:6334").build()?;

client
    .scroll(
        ScrollPointsBuilder::new("{collection_name}").filter(Filter::must_not([
            Condition::matches("city", "london".to_string()),
            Condition::matches("color", "red".to_string()),
        ])),
    )
    .await?;

import java.util.List;

import static io.qdrant.client.ConditionFactory.matchKeyword;

import io.qdrant.client.grpc.Points.Filter;
import io.qdrant.client.grpc.Points.ScrollPoints;

client
    .scrollAsync(
        ScrollPoints.newBuilder()
            .setCollectionName("{collection_name}")
            .setFilter(
                Filter.newBuilder()
                    .addAllMustNot(
                        List.of(matchKeyword("city", "London"), matchKeyword("color", "red")))
                    .build())
            .build())
    .get();

using Qdrant.Client;
using static Qdrant.Client.Grpc.Conditions;

var client = new QdrantClient("localhost", 6334);

// The ! operator negates the condition(must not)
await client.ScrollAsync(
  collectionName: "{collection_name}",
  filter: !(MatchKeyword("city", "London") & MatchKeyword("color", "red"))
);

import (
  "context"

  "github.com/qdrant/go-client/qdrant"
)

client, err := qdrant.NewClient(&qdrant.Config{
  Host: "localhost",
  Port: 6334,
})

client.Scroll(context.Background(), &qdrant.ScrollPoints{
  CollectionName: "{collection_name}",
  Filter: &qdrant.Filter{
      MustNot: []*qdrant.Condition{
          qdrant.NewMatch("city", "London"),
          qdrant.NewMatch("color", "red"),
      },
  },
})

Результатом фильтрации будут точки:

[
  { "id": 5, "city": "Moscow", "color": "green" },
  { "id": 6, "city": "Moscow", "color": "blue" }
]

При использовании must_not предложение становится true, если ни одно из условий, перечисленных внутри must_not, не выполняется. В этом смысле must_not эквивалентно выражению (NOT A) AND (NOT B) AND (NOT C).

Комбинирование операторов#

Операторы можно использовать одновременно, например:

POST /collections/{collection_name}/points/scroll
{
    "filter": {
        "must": [
            { "key": "city", "match": { "value": "London" } }
        ],
        "must_not": [
            { "key": "color", "match": { "value": "red" } }
        ]
    }
}

client.scroll(
    collection_name="{collection_name}",
    scroll_filter=models.Filter(
        must=[
            models.FieldCondition(key="city", match=models.MatchValue(value="London")),
        ],
        must_not=[
            models.FieldCondition(key="color", match=models.MatchValue(value="red")),
        ],
    ),
)

client.scroll("{collection_name}", {
  filter: {
    must: [
      {
        key: "city",
        match: { value: "London" },
      },
    ],
    must_not: [
      {
        key: "color",
        match: { value: "red" },
      },
    ],
  },
});

use qdrant_client::qdrant::{Condition, Filter, ScrollPointsBuilder};

client
    .scroll(
        ScrollPointsBuilder::new("{collection_name}").filter(Filter {
            must: vec![Condition::matches("city", "London".to_string())],
            must_not: vec![Condition::matches("color", "red".to_string())],
            ..Default::default()
        }),
    )
    .await?;

import static io.qdrant.client.ConditionFactory.matchKeyword;

import io.qdrant.client.grpc.Points.Filter;
import io.qdrant.client.grpc.Points.ScrollPoints;

client
    .scrollAsync(
        ScrollPoints.newBuilder()
            .setCollectionName("{collection_name}")
            .setFilter(
                Filter.newBuilder()
                    .addMust(matchKeyword("city", "London"))
                    .addMustNot(matchKeyword("color", "red"))
                    .build())
            .build())
    .get();

using Qdrant.Client;
using static Qdrant.Client.Grpc.Conditions;

var client = new QdrantClient("localhost", 6334);

await client.ScrollAsync(
  collectionName: "{collection_name}",
  filter: MatchKeyword("city", "London") & !MatchKeyword("color", "red")
);

import (
  "context"

  "github.com/qdrant/go-client/qdrant"
)

client, err := qdrant.NewClient(&qdrant.Config{
  Host: "localhost",
  Port: 6334,
})

client.Scroll(context.Background(), &qdrant.ScrollPoints{
  CollectionName: "{collection_name}",
  Filter: &qdrant.Filter{
      Must: []*qdrant.Condition{
          qdrant.NewMatch("city", "London"),
      },
      MustNot: []*qdrant.Condition{
          qdrant.NewMatch("color", "red"),
      },
  },
})

Результатом фильтрации будут точки:

[
  { "id": 1, "city": "London", "color": "green" },
  { "id": 3, "city": "London", "color": "blue" }
]

В данном случае операторы объединены с помощью AND.

Кроме того, операторы могут быть рекурсивно вложены друг в друга. Например:

POST /collections/{collection_name}/points/scroll
{
    "filter": {
        "must_not": [
            {
                "must": [
                    { "key": "city", "match": { "value": "London" } },
                    { "key": "color", "match": { "value": "red" } }
                ]
            }
        ]
    }
}

client.scroll(
    collection_name="{collection_name}",
    scroll_filter=models.Filter(
        must_not=[
            models.Filter(
                must=[
                    models.FieldCondition(
                        key="city", match=models.MatchValue(value="London")
                    ),
                    models.FieldCondition(
                        key="color", match=models.MatchValue(value="red")
                    ),
                ],
            ),
        ],
    ),
)

client.scroll("{collection_name}", {
  filter: {
    must_not: [
      {
        must: [
          {
            key: "city",
            match: { value: "London" },
          },
          {
            key: "color",
            match: { value: "red" },
          },
        ],
      },
    ],
  },
});

use qdrant_client::qdrant::{Condition, Filter, ScrollPointsBuilder};

client
    .scroll(
        ScrollPointsBuilder::new("{collection_name}").filter(Filter::must_not([Filter::must(
            [
                Condition::matches("city", "London".to_string()),
                Condition::matches("color", "red".to_string()),
            ],
        )
        .into()])),
    )
    .await?;

import java.util.List;

import static io.qdrant.client.ConditionFactory.filter;
import static io.qdrant.client.ConditionFactory.matchKeyword;

import io.qdrant.client.grpc.Points.Filter;
import io.qdrant.client.grpc.Points.ScrollPoints;

client
    .scrollAsync(
        ScrollPoints.newBuilder()
            .setCollectionName("{collection_name}")
            .setFilter(
                Filter.newBuilder()
                    .addMustNot(
                        filter(
                            Filter.newBuilder()
                                .addAllMust(
                                    List.of(
                                        matchKeyword("city", "London"),
                                        matchKeyword("color", "red")))
                                .build()))
                    .build())
            .build())
    .get();

using Qdrant.Client;
using Qdrant.Client.Grpc;
using static Qdrant.Client.Grpc.Conditions;

var client = new QdrantClient("localhost", 6334);

await client.ScrollAsync(
  collectionName: "{collection_name}",
  filter: new Filter { MustNot = { MatchKeyword("city", "London") & MatchKeyword("color", "red") } }
);

import (
  "context"

  "github.com/qdrant/go-client/qdrant"
)

client, err := qdrant.NewClient(&qdrant.Config{
  Host: "localhost",
  Port: 6334,
})

client.Scroll(context.Background(), &qdrant.ScrollPoints{
  CollectionName: "{collection_name}",
  Filter: &qdrant.Filter{
      MustNot: []*qdrant.Condition{
          qdrant.NewFilterAsCondition(&qdrant.Filter{
              Must: []*qdrant.Condition{
                  qdrant.NewMatch("city", "London"),
                  qdrant.NewMatch("color", "red"),
              },
          }),
      },
  },
})

Результатом фильтрации будут точки:

[
  { "id": 1, "city": "London", "color": "green" },
  { "id": 3, "city": "London", "color": "blue" },
  { "id": 4, "city": "Berlin", "color": "red" },
  { "id": 5, "city": "Moscow", "color": "green" },
  { "id": 6, "city": "Moscow", "color": "blue" }
]

Условия фильтрации#

Различные типы значений в полезной нагрузке соответствуют разным видам запросов, которые можно к ним применить.

Match (соответствие)#

{
  "key": "color",
  "match": {
    "value": "red"
  }
}

models.FieldCondition(
    key="color",
    match=models.MatchValue(value="red"),
)

{
    key: 'color', 
    match: {value: 'red'}
}

Condition::matches("color", "red".to_string())

matchKeyword("color", "red");

using static Qdrant.Client.Grpc.Conditions;

MatchKeyword("color", "red");

import "github.com/qdrant/go-client/qdrant"

qdrant.NewMatch("color", "red")

Для других типов условие соответствия будет выглядеть точно так же, за исключением используемого типа:

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

models.FieldCondition(
    key="count",
    match=models.MatchValue(value=0),
)

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

Condition::matches("count", 0)

import static io.qdrant.client.ConditionFactory.match;

match("count", 0);

using static Qdrant.Client.Grpc.Conditions;

Match("count", 0);

import "github.com/qdrant/go-client/qdrant"

qdrant.NewMatchInt("count", 0)

Самый простой вид условия — проверка равенства сохраненного значения заданному. Если хранится несколько значений, хотя бы одно из них должно соответствовать условию. Его можно применять для полезных нагрузок типа keyword (ключевое слово), integer (целое число) и bool (бинарное значение).

Match Any (соответствие любому)#

Если необходимо проверить, является ли сохраненное значение одним из нескольких возможных значений, можно воспользоваться условием Match Any. Match Any работает как логическое OR («ИЛИ») для указанных значений. Его также можно описать как оператор IN.

Условие можно применять к полезным нагрузкам типа keyword или integer.

Пример:

{
  "key": "color",
  "match": {
    "any": ["black", "yellow"]
  }
}

models.FieldCondition(
    key="color",
    match=models.MatchAny(any=["black", "yellow"]),
)

{
    key: 'color',
    match: {any: ['black', 'yellow']}    
}

Condition::matches("color", vec!["black".to_string(), "yellow".to_string()])

import static io.qdrant.client.ConditionFactory.matchKeywords;

matchKeywords("color", List.of("black", "yellow"));

using static Qdrant.Client.Grpc.Conditions;

Match("color", ["black", "yellow"]);

import "github.com/qdrant/go-client/qdrant"

qdrant.NewMatchKeywords("color", "black", "yellow")

В этом примере условие будет удовлетворено, если сохраненное значение равно либо black, либо yellow.

Если сохраненное значение представляет собой массив, он должно содержать хотя бы одно значение, совпадающее с любым из указанных значений. Например, если сохраненное значение - ["black", "green"], условие будет удовлетворено, поскольку "black" входит в состав ["black", "yellow"].

Match Except (соответствие за исключением)#

Если необходимо проверить, что сохраненное значение не соответствует одному из нескольких возможных значений, можно воспользоваться условием Match Except. Match Except работает как логический NOR («ИЛИ-НЕ») для указанных значений. Его также можно описать как оператор NOT IN.

Условие можно применять к полезным нагрузкам типа keyword или integer.

Пример:

{
  "key": "color",
  "match": {
    "except": ["black", "yellow"]
  }
}

models.FieldCondition(
    key="color",
    match=models.MatchExcept(**{"except": ["black", "yellow"]}),
)

{
    key: 'color',
    match: {except: ['black', 'yellow']}
}

use qdrant_client::qdrant::r#match::MatchValue;

Condition::matches(
    "color",
    !MatchValue::from(vec!["black".to_string(), "yellow".to_string()]),
)

import static io.qdrant.client.ConditionFactory.matchExceptKeywords;

matchExceptKeywords("color", List.of("black", "yellow"));

using static Qdrant.Client.Grpc.Conditions;

Match("color", ["black", "yellow"]);

import "github.com/qdrant/go-client/qdrant"

qdrant.NewMatchExcept("color", "black", "yellow")

В этом примере условие будет удовлетворено, если сохраненное значение не равно ни black, ни yellow.

Если сохраненное значение представляет собой массив, оно должно содержать хотя бы одно значение, которое не совпадает ни с одним из указанных значений. Например, если сохраненное значение - ["black", "green"], условие будет удовлетворено, потому что "green" не совпадает ни с "black", ни с "yellow".

Nested key (вложенный ключ)#

Поскольку полезные нагрузки являются произвольными объектами 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"
                }
            }
        ]
    }
}

client.scroll(
    collection_name="{collection_name}",
    scroll_filter=models.Filter(
        should=[
            models.FieldCondition(
                key="country.name", match=models.MatchValue(value="Germany")
            ),
        ],
    ),
)

client.scroll("{collection_name}", {
  filter: {
    should: [
      {
        key: "country.name",
        match: { value: "Germany" },
      },
    ],
  },
});

use qdrant_client::qdrant::{Condition, Filter, ScrollPointsBuilder};

client
    .scroll(
        ScrollPointsBuilder::new("{collection_name}").filter(Filter::should([
            Condition::matches("country.name", "Germany".to_string()),
        ])),
    )
    .await?;

import static io.qdrant.client.ConditionFactory.matchKeyword;

import io.qdrant.client.grpc.Points.Filter;
import io.qdrant.client.grpc.Points.ScrollPoints;

client
    .scrollAsync(
        ScrollPoints.newBuilder()
            .setCollectionName("{collection_name}")
            .setFilter(
                Filter.newBuilder()
                    .addShould(matchKeyword("country.name", "Germany"))
                    .build())
            .build())
    .get();

using Qdrant.Client;
using Qdrant.Client.Grpc;
using static Qdrant.Client.Grpc.Conditions;

var client = new QdrantClient("localhost", 6334);

await client.ScrollAsync(collectionName: "{collection_name}", filter: MatchKeyword("country.name", "Germany"));

import (
  "context"

  "github.com/qdrant/go-client/qdrant"
)

client, err := qdrant.NewClient(&qdrant.Config{
  Host: "localhost",
  Port: 6334,
})

client.Scroll(context.Background(), &qdrant.ScrollPoints{
  CollectionName: "{collection_name}",
  Filter: &qdrant.Filter{
      Should: []*qdrant.Condition{
          qdrant.NewMatch("country.name", "Germany"),
      },
  },
})

Также можно выполнять поиск по массивам, проецируя внутренние значения с использованием синтаксиса []:

POST /collections/{collection_name}/points/scroll
{
    "filter": {
        "should": [
            {
                "key": "country.cities[].population",
                "range": {
                    "gte": 9.0,
                }
            }
        ]
    }
}

client.scroll(
    collection_name="{collection_name}",
    scroll_filter=models.Filter(
        should=[
            models.FieldCondition(
                key="country.cities[].population",
                range=models.Range(
                    gt=None,
                    gte=9.0,
                    lt=None,
                    lte=None,
                ),
            ),
        ],
    ),
)

client.scroll("{collection_name}", {
  filter: {
    should: [
      {
        key: "country.cities[].population",
        range: {
          gt: null,
          gte: 9.0,
          lt: null,
          lte: null,
        },
      },
    ],
  },
});

use qdrant_client::qdrant::{Condition, Filter, Range, ScrollPointsBuilder};

client
    .scroll(
        ScrollPointsBuilder::new("{collection_name}").filter(Filter::should([
            Condition::range(
                "country.cities[].population",
                Range {
                    gte: Some(9.0),
                    ..Default::default()
                },
            ),
        ])),
    )
    .await?;

import static io.qdrant.client.ConditionFactory.range;

import io.qdrant.client.grpc.Points.Filter;
import io.qdrant.client.grpc.Points.Range;
import io.qdrant.client.grpc.Points.ScrollPoints;

client
    .scrollAsync(
        ScrollPoints.newBuilder()
            .setCollectionName("{collection_name}")
            .setFilter(
                Filter.newBuilder()
                    .addShould(
                        range(
                            "country.cities[].population",
                            Range.newBuilder().setGte(9.0).build()))
                    .build())
            .build())
    .get();

using Qdrant.Client;
using static Qdrant.Client.Grpc.Conditions;

var client = new QdrantClient("localhost", 6334);

await client.ScrollAsync(
  collectionName: "{collection_name}",
  filter: Range("country.cities[].population", new Qdrant.Client.Grpc.Range { Gte = 9.0 })
);

import (
  "context"

  "github.com/qdrant/go-client/qdrant"
)

client, err := qdrant.NewClient(&qdrant.Config{
  Host: "localhost",
  Port: 6334,
})

client.Scroll(context.Background(), &qdrant.ScrollPoints{
  CollectionName: "{collection_name}",
  Filter: &qdrant.Filter{
      Should: []*qdrant.Condition{
          qdrant.NewRange("country.cities[].population", &qdrant.Range{
              Gte: qdrant.PtrOf(9.0),
          }),
      },
  },
})

Запрос вернет точку только с идентификатором 2, так как только Япония имеет город с населением более 9.0 человек.

И листовое вложенное поле (конечный элемент в структуре данных (например, JSON), не содержащий вложенных объектов), которое также может быть массивом.

POST /collections/{collection_name}/points/scroll
{
    "filter": {
        "should": [
            {
                "key": "country.cities[].sightseeing",
                "match": {
                    "value": "Osaka Castle"
                }
            }
        ]
    }
}

client.scroll(
    collection_name="{collection_name}",
    scroll_filter=models.Filter(
        should=[
            models.FieldCondition(
                key="country.cities[].sightseeing",
                match=models.MatchValue(value="Osaka Castle"),
            ),
        ],
    ),
)

client.scroll("{collection_name}", {
  filter: {
    should: [
      {
        key: "country.cities[].sightseeing",
        match: { value: "Osaka Castle" },
      },
    ],
  },
});

use qdrant_client::qdrant::{Condition, Filter, ScrollPointsBuilder};

client
    .scroll(
        ScrollPointsBuilder::new("{collection_name}").filter(Filter::should([
            Condition::matches("country.cities[].sightseeing", "Osaka Castle".to_string()),
        ])),
    )
    .await?;

import static io.qdrant.client.ConditionFactory.matchKeyword;

import io.qdrant.client.grpc.Points.Filter;
import io.qdrant.client.grpc.Points.ScrollPoints;

client
    .scrollAsync(
        ScrollPoints.newBuilder()
            .setCollectionName("{collection_name}")
            .setFilter(
                Filter.newBuilder()
                    .addShould(matchKeyword("country.cities[].sightseeing", "Germany"))
                    .build())
            .build())
    .get();

using Qdrant.Client;
using static Qdrant.Client.Grpc.Conditions;

var client = new QdrantClient("localhost", 6334);

await client.ScrollAsync(
  collectionName: "{collection_name}",
  filter: MatchKeyword("country.cities[].sightseeing", "Germany")
);

import (
  "context"

  "github.com/qdrant/go-client/qdrant"
)

client, err := qdrant.NewClient(&qdrant.Config{
  Host: "localhost",
  Port: 6334,
})

client.Scroll(context.Background(), &qdrant.ScrollPoints{
  CollectionName: "{collection_name}",
  Filter: &qdrant.Filter{
      Should: []*qdrant.Condition{
          qdrant.NewMatch("country.cities[].sightseeing", "Germany"),
      },
  },
})

Запрос вернет точку только с идентификатором 2, так как только Япония имеет город, где достопримечательностью является «Замок Осака».

Nested Object filter (фильтр вложенных объектов)#

По умолчанию условия учитывают всю полезную нагрузку точки.

Рассмотрим две точки со следующей полезной нагрузкой:

[
  {
    "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
                }
            }
        ]
    }
}

client.scroll(
    collection_name="{collection_name}",
    scroll_filter=models.Filter(
        must=[
            models.FieldCondition(
                key="diet[].food", match=models.MatchValue(value="meat")
            ),
            models.FieldCondition(
                key="diet[].likes", match=models.MatchValue(value=True)
            ),
        ],
    ),
)

client.scroll("{collection_name}", {
  filter: {
    must: [
      {
        key: "diet[].food",
        match: { value: "meat" },
      },
      {
        key: "diet[].likes",
        match: { value: true },
      },
    ],
  },
});

use qdrant_client::qdrant::{Condition, Filter, ScrollPointsBuilder};

client
    .scroll(
        ScrollPointsBuilder::new("{collection_name}").filter(Filter::must([
            Condition::matches("diet[].food", "meat".to_string()),
            Condition::matches("diet[].likes", true),
        ])),
    )
    .await?;

import java.util.List;

import static io.qdrant.client.ConditionFactory.match;
import static io.qdrant.client.ConditionFactory.matchKeyword;

import io.qdrant.client.QdrantClient;
import io.qdrant.client.QdrantGrpcClient;
import io.qdrant.client.grpc.Points.Filter;
import io.qdrant.client.grpc.Points.ScrollPoints;

QdrantClient client =
    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());

client
    .scrollAsync(
        ScrollPoints.newBuilder()
            .setCollectionName("{collection_name}")
            .setFilter(
                Filter.newBuilder()
                    .addAllMust(
                        List.of(matchKeyword("diet[].food", "meat"), match("diet[].likes", true)))
                    .build())
            .build())
    .get();

using Qdrant.Client;
using static Qdrant.Client.Grpc.Conditions;

var client = new QdrantClient("localhost", 6334);

await client.ScrollAsync(
  collectionName: "{collection_name}",
  filter: MatchKeyword("diet[].food", "meat") & Match("diet[].likes", true)
);

import (
  "context"

  "github.com/qdrant/go-client/qdrant"
)

client, err := qdrant.NewClient(&qdrant.Config{
  Host: "localhost",
  Port: 6334,
})

client.Scroll(context.Background(), &qdrant.ScrollPoints{
  CollectionName: "{collection_name}",
  Filter: &qdrant.Filter{
      Must: []*qdrant.Condition{
          qdrant.NewMatch("diet[].food", "meat"),
          qdrant.NewMatchBool("diet[].likes", true),
      },
  },
})

Это происходит потому, что обе точки удовлетворяют двум условиям:

  • «T-Rex» соответствует food=meat на diet[1].food и likes=true на diet[1].likes

  • «Diplodocus» соответствует food=meat на diet[1].food и likes=true на diet[0].likes

Чтобы получить только те точки, которые соответствуют условиям на основе элементов массива, то есть точку с идентификатором 1 в этом примере, понадобится фильтр вложенных объектов.

Фильтры вложенных объектов позволяют независимо запрашивать массивы объектов.

Он достигается путем использования типа условия nested, сформированного ключевым полем полезной нагрузки и применяемым фильтром.

Ключ должен указывать на массив объектов и может использоваться как с обозначением скобками (data или data[]), так и без них.

POST /collections/{collection_name}/points/scroll
{
    "filter": {
        "must": [{
            "nested": {
                "key": "diet",
                "filter":{
                    "must": [
                        {
                            "key": "food",
                            "match": {
                                "value": "meat"
                            }
                        },
                        {
                            "key": "likes",
                            "match": {
                                "value": true
                            }
                        }
                    ]
                }
            }
        }]
    }
}

client.scroll(
    collection_name="{collection_name}",
    scroll_filter=models.Filter(
        must=[
            models.NestedCondition(
                nested=models.Nested(
                    key="diet",
                    filter=models.Filter(
                        must=[
                            models.FieldCondition(
                                key="food", match=models.MatchValue(value="meat")
                            ),
                            models.FieldCondition(
                                key="likes", match=models.MatchValue(value=True)
                            ),
                        ]
                    ),
                )
            )
        ],
    ),
)

client.scroll("{collection_name}", {
  filter: {
    must: [
      {
        nested: {
          key: "diet",
          filter: {
            must: [
              {
                key: "food",
                match: { value: "meat" },
              },
              {
                key: "likes",
                match: { value: true },
              },
            ],
          },
        },
      },
    ],
  },
});

use qdrant_client::qdrant::{Condition, Filter, NestedCondition, ScrollPointsBuilder};

client
    .scroll(
        ScrollPointsBuilder::new("{collection_name}").filter(Filter::must([NestedCondition {
            key: "diet".to_string(),
            filter: Some(Filter::must([
                Condition::matches("food", "meat".to_string()),
                Condition::matches("likes", true),
            ])),
        }
        .into()])),
    )
    .await?;

import java.util.List;

import static io.qdrant.client.ConditionFactory.match;
import static io.qdrant.client.ConditionFactory.matchKeyword;
import static io.qdrant.client.ConditionFactory.nested;

import io.qdrant.client.grpc.Points.Filter;
import io.qdrant.client.grpc.Points.ScrollPoints;

client
    .scrollAsync(
        ScrollPoints.newBuilder()
            .setCollectionName("{collection_name}")
            .setFilter(
                Filter.newBuilder()
                    .addMust(
                        nested(
                            "diet",
                            Filter.newBuilder()
                                .addAllMust(
                                    List.of(
                                        matchKeyword("food", "meat"), match("likes", true)))
                                .build()))
                    .build())
            .build())
    .get();

using Qdrant.Client;
using static Qdrant.Client.Grpc.Conditions;

var client = new QdrantClient("localhost", 6334);

await client.ScrollAsync(
  collectionName: "{collection_name}",
  filter: Nested("diet", MatchKeyword("food", "meat") & Match("likes", true))
);

import (
  "context"

  "github.com/qdrant/go-client/qdrant"
)

client, err := qdrant.NewClient(&qdrant.Config{
  Host: "localhost",
  Port: 6334,
})

client.Scroll(context.Background(), &qdrant.ScrollPoints{
  CollectionName: "{collection_name}",
  Filter: &qdrant.Filter{
      Must: []*qdrant.Condition{
          qdrant.NewNestedFilter("diet", &qdrant.Filter{
              Must: []*qdrant.Condition{
                  qdrant.NewMatch("food", "meat"),
                  qdrant.NewMatchBool("likes", true),
              },
          }),
      },
  },
})

Логика сопоставления модифицируется таким образом, чтобы применяться на уровне элемента массива в полезной нагрузке.

Фильтры вложенных объектов работают аналогично применению вложенного фильтра к каждому элементу массива отдельно. Родительский документ считается соответствующим условию, если хотя бы один элемент массива соответствует вложенному фильтру.

Ограничения#

Условие has_id не поддерживается в фильтре вложенных объектов. Если он нужен, поместите его в соседний пункт must.

POST /collections/{collection_name}/points/scroll
{
   "filter":{
      "must":[
         {
            "nested":{
               "key":"diet",
               "filter":{
                  "must":[
                     {
                        "key":"food",
                        "match":{
                           "value":"meat"
                        }
                     },
                     {
                        "key":"likes",
                        "match":{
                           "value":true
                        }
                     }
                  ]
               }
            }
         },
         {
            "has_id":[
               1
            ]
         }
      ]
   }
}

client.scroll(
    collection_name="{collection_name}",
    scroll_filter=models.Filter(
        must=[
            models.NestedCondition(
                nested=models.Nested(
                    key="diet",
                    filter=models.Filter(
                        must=[
                            models.FieldCondition(
                                key="food", match=models.MatchValue(value="meat")
                            ),
                            models.FieldCondition(
                                key="likes", match=models.MatchValue(value=True)
                            ),
                        ]
                    ),
                )
            ),
            models.HasIdCondition(has_id=[1]),
        ],
    ),
)

client.scroll("{collection_name}", {
  filter: {
    must: [
      {
        nested: {
          key: "diet",
          filter: {
            must: [
              {
                key: "food",
                match: { value: "meat" },
              },
              {
                key: "likes",
                match: { value: true },
              },
            ],
          },
        },
      },
      {
        has_id: [1],
      },
    ],
  },
});

use qdrant_client::qdrant::{Condition, Filter, NestedCondition, ScrollPointsBuilder};

client
    .scroll(
        ScrollPointsBuilder::new("{collection_name}").filter(Filter::must([
            NestedCondition {
                key: "diet".to_string(),
                filter: Some(Filter::must([
                    Condition::matches("food", "meat".to_string()),
                    Condition::matches("likes", true),
                ])),
            }
            .into(),
            Condition::has_id([1]),
        ])),
    )
    .await?;

import java.util.List;

import static io.qdrant.client.ConditionFactory.hasId;
import static io.qdrant.client.ConditionFactory.match;
import static io.qdrant.client.ConditionFactory.matchKeyword;
import static io.qdrant.client.ConditionFactory.nested;
import static io.qdrant.client.PointIdFactory.id;

import io.qdrant.client.grpc.Points.Filter;
import io.qdrant.client.grpc.Points.ScrollPoints;

client
    .scrollAsync(
        ScrollPoints.newBuilder()
            .setCollectionName("{collection_name}")
            .setFilter(
                Filter.newBuilder()
                    .addMust(
                        nested(
                            "diet",
                            Filter.newBuilder()
                                .addAllMust(
                                    List.of(
                                        matchKeyword("food", "meat"), match("likes", true)))
                                .build()))
                    .addMust(hasId(id(1)))
                    .build())
            .build())
    .get();

using Qdrant.Client;
using static Qdrant.Client.Grpc.Conditions;

var client = new QdrantClient("localhost", 6334);

await client.ScrollAsync(
  collectionName: "{collection_name}",
  filter: Nested("diet", MatchKeyword("food", "meat") & Match("likes", true)) & HasId(1)
);

import (
  "context"

  "github.com/qdrant/go-client/qdrant"
)

client, err := qdrant.NewClient(&qdrant.Config{
  Host: "localhost",
  Port: 6334,
})

client.Scroll(context.Background(), &qdrant.ScrollPoints{
  CollectionName: "{collection_name}",
  Filter: &qdrant.Filter{
      Must: []*qdrant.Condition{
          qdrant.NewNestedFilter("diet", &qdrant.Filter{
              Must: []*qdrant.Condition{
                  qdrant.NewMatch("food", "meat"),
                  qdrant.NewMatchBool("likes", true),
              },
          }),
          qdrant.NewHasID(qdrant.NewIDNum(1)),
      },
  },
})

Full Text Match (точное соответствие текста)#

Особый случай условия match - условие точного соответствия текста text. Оно позволяет искать конкретную подстроку, токен или фразу в текстовом поле.

Какие именно точные тексты будут соответствовать условию, зависит от конфигурации полнотекстового индекса. Конфигурация определяется при создании индекса и описана в разделе полнотекстовый индекс.

Если для поля нет полнотекстового индекса, условие будет работать как точное соответствие подстроке.

{
  "key": "description",
  "match": {
    "text": "good cheap"
  }
}

models.FieldCondition(
    key="description",
    match=models.MatchText(text="good cheap"),
)

{
    key: 'description',
    match: {text: 'good cheap'}    
}

use qdrant_client::qdrant::Condition;

Condition::matches_text("description", "good cheap")

import static io.qdrant.client.ConditionFactory.matchText;

matchText("description", "good cheap");

using static Qdrant.Client.Grpc.Conditions;

MatchText("description", "good cheap");

import "github.com/qdrant/go-client/qdrant"

qdrant.NewMatchText("description", "good cheap")

Если запрос содержит несколько слов, условие будет удовлетворено только в том случае, если все они присутствуют в тексте.

Range (диапазон)#

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

models.FieldCondition(
    key="price",
    range=models.Range(
        gt=None,
        gte=100.0,
        lt=None,
        lte=450.0,
    ),
)

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

use qdrant_client::qdrant::{Condition, Range};

Condition::range(
    "price",
    Range {
        gt: None,
        gte: Some(100.0),
        lt: None,
        lte: Some(450.0),
    },
)

import static io.qdrant.client.ConditionFactory.range;

import io.qdrant.client.grpc.Points.Range;

range("price", Range.newBuilder().setGte(100.0).setLte(450).build());

using static Qdrant.Client.Grpc.Conditions;

Range("price", new Qdrant.Client.Grpc.Range { Gte = 100.0, Lte = 450 });

import "github.com/qdrant/go-client/qdrant"

qdrant.NewRange("price", &qdrant.Range{
  Gte: qdrant.PtrOf(100.0),
  Lte: qdrant.PtrOf(450.0),
})

Условие range устанавливает диапазон допустимых значений для хранимых значений полезной нагрузки. Если хранится несколько значений, хотя бы одно из них должно соответствовать условию.

Возможные сравнения:

  • gt - больше чем;

  • gte - больше или равно;

  • lt - меньше чем;

  • lte - меньше или равно.

Может применяться к полезным нагрузкам типа float (вещественное число) и integer (целое число).

Datetime Range (диапазон дат и времени)#

Диапазон дат и времени — уникальное условие диапазона, предназначенное для полезных нагрузок типа datetime (дата и время), поддерживающее форматы RFC 3339. Не нужно преобразовывать даты в метки времени Unix так как во время сравнения временные метки анализируются и конвертируются в формат UTC.

{
  "key": "date",
  "range": {
    "gt": "2023-02-08T10:49:00Z",
    "gte": null,
    "lt": null,
    "lte": "2024-01-31 10:14:31Z"
  }
}

models.FieldCondition(
    key="date",
    range=models.DatetimeRange(
        gt="2023-02-08T10:49:00Z",
        gte=None,
        lt=None,
        lte="2024-01-31T10:14:31Z",
    ),
)

{
    key: 'date',
    range: {
        gt: '2023-02-08T10:49:00Z',
        gte: null,
        lt: null,
        lte: '2024-01-31T10:14:31Z'
    }
}

use qdrant_client::qdrant::{Condition, DatetimeRange, Timestamp};

Condition::datetime_range(
    "date",
    DatetimeRange {
        gt: Some(Timestamp::date_time(2023, 2, 8, 10, 49, 0).unwrap()),
        gte: None,
        lt: None,
        lte: Some(Timestamp::date_time(2024, 1, 31, 10, 14, 31).unwrap()),
    },
)

import static io.qdrant.client.ConditionFactory.datetimeRange;

import com.google.protobuf.Timestamp;
import io.qdrant.client.grpc.Points.DatetimeRange;
import java.time.Instant;

long gt = Instant.parse("2023-02-08T10:49:00Z").getEpochSecond();
long lte = Instant.parse("2024-01-31T10:14:31Z").getEpochSecond();

datetimeRange("date",
    DatetimeRange.newBuilder()
        .setGt(Timestamp.newBuilder().setSeconds(gt))
        .setLte(Timestamp.newBuilder().setSeconds(lte))
        .build());

using Qdrant.Client.Grpc;

Conditions.DatetimeRange(
    field: "date",
    gt: new DateTime(2023, 2, 8, 10, 49, 0, DateTimeKind.Utc),
    lte: new DateTime(2024, 1, 31, 10, 14, 31, DateTimeKind.Utc)
);

import (
  "time"

  "github.com/qdrant/go-client/qdrant"
  "google.golang.org/protobuf/types/known/timestamppb"
)

qdrant.NewDatetimeRange("date", &qdrant.DatetimeRange{
  Gt:  timestamppb.New(time.Date(2023, 2, 8, 10, 49, 0, 0, time.UTC)),
  Lte: timestamppb.New(time.Date(2024, 1, 31, 10, 14, 31, 0, time.UTC)),
})

UUID Match (соответствие UUID)#

Сопоставление значений UUID работает аналогично обычному условию match для строк. Функционально оно будет работать одинаково с индексами keyword и uuid, но индекс uuid более эффективен с точки зрения потребления памяти.

{
  "key": "uuid",
  "match": {
    "value": "f47ac10b-58cc-4372-a567-0e02b2c3d479"
  }
}

models.FieldCondition(
    key="uuid",
    match=models.MatchValue(value="f47ac10b-58cc-4372-a567-0e02b2c3d479"),
)

{
    key: 'uuid',
    match: {value: 'f47ac10b-58cc-4372-a567-0e02b2c3d479'}    
}

Condition::matches("uuid", "f47ac10b-58cc-4372-a567-0e02b2c3d479".to_string())

matchKeyword("uuid", "f47ac10b-58cc-4372-a567-0e02b2c3d479");

using static Qdrant.Client.Grpc.Conditions;

MatchKeyword("uuid", "f47ac10b-58cc-4372-a567-0e02b2c3d479");

import "github.com/qdrant/go-client/qdrant"

qdrant.NewMatch("uuid", "f47ac10b-58cc-4372-a567-0e02b2c3d479")

Geo (геоданные)#

Geo Bounding Box (границы геопрямоугольника)#

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

models.FieldCondition(
    key="location",
    geo_bounding_box=models.GeoBoundingBox(
        bottom_right=models.GeoPoint(
            lon=13.455868,
            lat=52.495862,
        ),
        top_left=models.GeoPoint(
            lon=13.403683,
            lat=52.520711,
        ),
    ),
)

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

use qdrant_client::qdrant::{Condition, GeoBoundingBox, GeoPoint};

Condition::geo_bounding_box(
    "location",
    GeoBoundingBox {
        bottom_right: Some(GeoPoint {
            lon: 13.455868,
            lat: 52.495862,
        }),
        top_left: Some(GeoPoint {
            lon: 13.403683,
            lat: 52.520711,
        }),
    },
)

import static io.qdrant.client.ConditionFactory.geoBoundingBox;

geoBoundingBox("location", 52.520711, 13.403683, 52.495862, 13.455868);

using static Qdrant.Client.Grpc.Conditions;

GeoBoundingBox("location", 52.520711, 13.403683, 52.495862, 13.455868);

import "github.com/qdrant/go-client/qdrant"

qdrant.NewGeoBoundingBox("location", 52.520711, 13.403683, 52.495862, 13.455868)

Подходит для location внутри прямоугольника с координатами верхнего левого угла в bottom_right и координатами нижнего правого угла в top_left.

Geo Radius (георадиус)#

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

models.FieldCondition(
    key="location",
    geo_radius=models.GeoRadius(
        center=models.GeoPoint(
            lon=13.403683,
            lat=52.520711,
        ),
        radius=1000.0,
    ),
)

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

use qdrant_client::qdrant::{Condition, GeoPoint, GeoRadius};

Condition::geo_radius(
    "location",
    GeoRadius {
        center: Some(GeoPoint {
            lon: 13.403683,
            lat: 52.520711,
        }),
        radius: 1000.0,
    },
)

import static io.qdrant.client.ConditionFactory.geoRadius;

geoRadius("location", 52.520711, 13.403683, 1000.0f);

using static Qdrant.Client.Grpc.Conditions;

GeoRadius("location", 52.520711, 13.403683, 1000.0f);

import "github.com/qdrant/go-client/qdrant"

qdrant.NewGeoRadius("location", 52.520711, 13.403683, 1000.0)

Подходит для location внутри круга с центром в точке center и радиусом radius метров.

Если хранятся несколько значений, хотя бы одно из них должно соответствовать условию. Эти условия применимы только к полезным нагрузкам, соответствующим формату геоданных.

Geo Polygon (геополигон)#

Поиск по геополигонам полезен, когда требуется найти точки внутри области неправильной формы, например границы страны или леса. Полигон всегда имеет внешнюю границу и может дополнительно включать внутренние кольца. Озеро с островом могло бы служить примером внутреннего кольца. Если необходимо найти точки в воде, а не на острове, создайте внутреннее кольцо для острова.

Когда определяете кольцо, необходимо выбрать порядок следования точек по часовой стрелке или против часовой стрелки. Первая и последняя точка полигона должна быть одинаковой.

На данный момент поддерживаются только глобальные непривязанные координаты (десятичные градусы долготы и широты).

{
  "key": "location",
  "geo_polygon": {
    "exterior": {
      "points": [
        { "lon": -70.0, "lat": -70.0 },
        { "lon": 60.0, "lat": -70.0 },
        { "lon": 60.0, "lat": 60.0 },
        { "lon": -70.0, "lat": 60.0 },
        { "lon": -70.0, "lat": -70.0 }
      ]
    },
    "interiors": [
      {
        "points": [
          { "lon": -65.0, "lat": -65.0 },
          { "lon": 0.0, "lat": -65.0 },
          { "lon": 0.0, "lat": 0.0 },
          { "lon": -65.0, "lat": 0.0 },
          { "lon": -65.0, "lat": -65.0 }
        ]
      }
    ]
  }
}

models.FieldCondition(
    key="location",
    geo_polygon=models.GeoPolygon(
        exterior=models.GeoLineString(
            points=[
                models.GeoPoint(
                    lon=-70.0,
                    lat=-70.0,
                ),
                models.GeoPoint(
                    lon=60.0,
                    lat=-70.0,
                ),
                models.GeoPoint(
                    lon=60.0,
                    lat=60.0,
                ),
                models.GeoPoint(
                    lon=-70.0,
                    lat=60.0,
                ),
                models.GeoPoint(
                    lon=-70.0,
                    lat=-70.0,
                ),
            ]
        ),
        interiors=[
            models.GeoLineString(
                points=[
                    models.GeoPoint(
                        lon=-65.0,
                        lat=-65.0,
                    ),
                    models.GeoPoint(
                        lon=0.0,
                        lat=-65.0,
                    ),
                    models.GeoPoint(
                        lon=0.0,
                        lat=0.0,
                    ),
                    models.GeoPoint(
                        lon=-65.0,
                        lat=0.0,
                    ),
                    models.GeoPoint(
                        lon=-65.0,
                        lat=-65.0,
                    ),
                ]
            )
        ],
    ),
)

{
  key: "location",
  geo_polygon: {
    exterior: {
      points: [
        {
          lon: -70.0,
          lat: -70.0
        },
        {
          lon: 60.0,
          lat: -70.0
        },
        {
          lon: 60.0,
          lat: 60.0
        },
        {
          lon: -70.0,
          lat: 60.0
        },
        {
          lon: -70.0,
          lat: -70.0
        }
      ]
    },
    interiors: [
      {
        points: [
          {
            lon: -65.0,
            lat: -65.0
          },
          {
            lon: 0,
            lat: -65.0
          },
          {
            lon: 0,
            lat: 0
          },
          {
            lon: -65.0,
            lat: 0
          },
          {
            lon: -65.0,
            lat: -65.0
          }
        ]
      }
    ]
  }
}

use qdrant_client::qdrant::{Condition, GeoLineString, GeoPoint, GeoPolygon};

Condition::geo_polygon(
    "location",
    GeoPolygon {
        exterior: Some(GeoLineString {
            points: vec![
                GeoPoint {
                    lon: -70.0,
                    lat: -70.0,
                },
                GeoPoint {
                    lon: 60.0,
                    lat: -70.0,
                },
                GeoPoint {
                    lon: 60.0,
                    lat: 60.0,
                },
                GeoPoint {
                    lon: -70.0,
                    lat: 60.0,
                },
                GeoPoint {
                    lon: -70.0,
                    lat: -70.0,
                },
            ],
        }),
        interiors: vec![GeoLineString {
            points: vec![
                GeoPoint {
                    lon: -65.0,
                    lat: -65.0,
                },
                GeoPoint {
                    lon: 0.0,
                    lat: -65.0,
                },
                GeoPoint { lon: 0.0, lat: 0.0 },
                GeoPoint {
                    lon: -65.0,
                    lat: 0.0,
                },
                GeoPoint {
                    lon: -65.0,
                    lat: -65.0,
                },
            ],
        }],
    },
)

import static io.qdrant.client.ConditionFactory.geoPolygon;

import io.qdrant.client.grpc.Points.GeoLineString;
import io.qdrant.client.grpc.Points.GeoPoint;

geoPolygon(
    "location",
    GeoLineString.newBuilder()
        .addAllPoints(
            List.of(
                GeoPoint.newBuilder().setLon(-70.0).setLat(-70.0).build(),
                GeoPoint.newBuilder().setLon(60.0).setLat(-70.0).build(),
                GeoPoint.newBuilder().setLon(60.0).setLat(60.0).build(),
                GeoPoint.newBuilder().setLon(-70.0).setLat(60.0).build(),
                GeoPoint.newBuilder().setLon(-70.0).setLat(-70.0).build()))
        .build(),
    List.of(
        GeoLineString.newBuilder()
            .addAllPoints(
                List.of(
                    GeoPoint.newBuilder().setLon(-65.0).setLat(-65.0).build(),
                    GeoPoint.newBuilder().setLon(0.0).setLat(-65.0).build(),
                    GeoPoint.newBuilder().setLon(0.0).setLat(0.0).build(),
                    GeoPoint.newBuilder().setLon(-65.0).setLat(0.0).build(),
                    GeoPoint.newBuilder().setLon(-65.0).setLat(-65.0).build()))
            .build()));

using Qdrant.Client.Grpc;
using static Qdrant.Client.Grpc.Conditions;

GeoPolygon(
  field: "location",
  exterior: new GeoLineString
  {
      Points =
      {
          new GeoPoint { Lat = -70.0, Lon = -70.0 },
          new GeoPoint { Lat = 60.0, Lon = -70.0 },
          new GeoPoint { Lat = 60.0, Lon = 60.0 },
          new GeoPoint { Lat = -70.0, Lon = 60.0 },
          new GeoPoint { Lat = -70.0, Lon = -70.0 }
      }
  },
  interiors: [
      new()
      {
          Points =
          {
              new GeoPoint { Lat = -65.0, Lon = -65.0 },
              new GeoPoint { Lat = 0.0, Lon = -65.0 },
              new GeoPoint { Lat = 0.0, Lon = 0.0 },
              new GeoPoint { Lat = -65.0, Lon = 0.0 },
              new GeoPoint { Lat = -65.0, Lon = -65.0 }
          }
      }
  ]
);

import "github.com/qdrant/go-client/qdrant"

qdrant.NewGeoPolygon("location",
  &qdrant.GeoLineString{
      Points: []*qdrant.GeoPoint{
          {Lat: -70, Lon: -70},
          {Lat: 60, Lon: -70},
          {Lat: 60, Lon: 60},
          {Lat: -70, Lon: 60},
          {Lat: -70, Lon: -70},
      },
  }, &qdrant.GeoLineString{
      Points: []*qdrant.GeoPoint{
          {Lat: -65, Lon: -65},
          {Lat: 0, Lon: -65},
          {Lat: 0, Lon: 0},
          {Lat: -65, Lon: 0},
          {Lat: -65, Lon: -65},
      },
  })

Совпадением считается любая точка расположенная внутри или на границах данного внешнего полигона, но не внутри каких-либо областей.

Если для точки хранится несколько значений координат, любое из них, соответствующее условию, включит эту точку в результат поиска. Эти условия применимы только к полезным нагрузкам, соответствующим формату геоданных.

Values count (фильтрация по количеству значений)#

Помимо прямого сравнения значений, также возможно фильтровать по количеству значений.

Например, учитывая следующие данные:

[
  { "id": 1, "name": "product A", "comments": ["Very good!", "Excellent"] },
  { "id": 2, "name": "product B", "comments": ["meh", "expected more", "ok"] }
]

Можно выполнить поиск только среди элементов с более чем двумя комментариями:

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

models.FieldCondition(
    key="comments",
    values_count=models.ValuesCount(gt=2),
)

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

use qdrant_client::qdrant::{Condition, ValuesCount};

Condition::values_count(
    "comments",
    ValuesCount {
        gt: Some(2),
        ..Default::default()
    },
)

import static io.qdrant.client.ConditionFactory.valuesCount;

import io.qdrant.client.grpc.Points.ValuesCount;

valuesCount("comments", ValuesCount.newBuilder().setGt(2).build());

using Qdrant.Client.Grpc;
using static Qdrant.Client.Grpc.Conditions;

ValuesCount("comments", new ValuesCount { Gt = 2 });

import "github.com/qdrant/go-client/qdrant"

qdrant.NewValuesCount("comments", &qdrant.ValuesCount{
  Gt: qdrant.PtrOf(uint64(2)),
})

Результатом будет:

[{ "id": 2, "name": "product B", "comments": ["meh", "expected more", "ok"] }]

Если сохраненное значение не является массивом, предполагается, что количество значений равно 1.

Is Empty (пустое значение)#

Иногда бывает полезно отфильтровать записи, в которых отсутствует какое-то значение. Для этих целей подойдет условие IsEmpty:

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

models.IsEmptyCondition(
    is_empty=models.PayloadField(key="reports"),
)

{
  is_empty: {
    key: "reports"
  }
}

use qdrant_client::qdrant::Condition;

Condition::is_empty("reports")

import static io.qdrant.client.ConditionFactory.isEmpty;

isEmpty("reports");

using Qdrant.Client.Grpc;
using static Qdrant.Client.Grpc.Conditions;

IsEmpty("reports");

import "github.com/qdrant/go-client/qdrant"

qdrant.NewIsEmpty("reports")

Это условие будет соответствовать всем записям, в которых поле reports либо вообще не существует, либо имеет значение null или [].

Условие IsEmpty часто удобно использовать совместно с логическим отрицанием must_not. В таком случае будут выбраны все непустые значения.

Is Null (нулевое значение)#

Проверка на NULL значения невозможна с помощью условия match. Вместо этого следует использовать условие IsNull:

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

models.IsNullCondition(
    is_null=models.PayloadField(key="reports"),
)

{
  is_null: {
    key: "reports"
  }
}

use qdrant_client::qdrant::Condition;

Condition::is_null("reports")

import static io.qdrant.client.ConditionFactory.isNull;

isNull("reports");

using Qdrant.Client.Grpc;
using static Qdrant.Client.Grpc.Conditions;

IsNull("reports");

import "github.com/qdrant/go-client/qdrant"

qdrant.NewIsNull("reports")

Условие будет соответствовать всем записям, в которых поле reports существует и имеет значение NULL.

Has id (имеет идентификатор)#

Данный тип запроса не связан с полезной нагрузкой, однако может оказаться очень полезным в некоторых ситуациях. Например, пользователь мог пометить некоторые конкретные результаты поиска как нерелевантные или нужно выполнить поиск только среди определенных точек.

POST /collections/{collection_name}/points/scroll
{
    "filter": {
        "must": [
            { "has_id": [1,3,5,7,9,11] }
        ]
    }
    ...
}

client.scroll(
    collection_name="{collection_name}",
    scroll_filter=models.Filter(
        must=[
            models.HasIdCondition(has_id=[1, 3, 5, 7, 9, 11]),
        ],
    ),
)

client.scroll("{collection_name}", {
  filter: {
    must: [
      {
        has_id: [1, 3, 5, 7, 9, 11],
      },
    ],
  },
});

use qdrant_client::qdrant::{Condition, Filter, ScrollPointsBuilder};
use qdrant_client::Qdrant;

let client = Qdrant::from_url("http://localhost:6334").build()?;
    
client
    .scroll(
        ScrollPointsBuilder::new("{collection_name}")
            .filter(Filter::must([Condition::has_id([1, 3, 5, 7, 9, 11])])),
    )
    .await?;

import java.util.List;

import static io.qdrant.client.ConditionFactory.hasId;
import static io.qdrant.client.PointIdFactory.id;

import io.qdrant.client.grpc.Points.Filter;
import io.qdrant.client.grpc.Points.ScrollPoints;

client
    .scrollAsync(
        ScrollPoints.newBuilder()
            .setCollectionName("{collection_name}")
            .setFilter(
                Filter.newBuilder()
                    .addMust(hasId(List.of(id(1), id(3), id(5), id(7), id(9), id(11))))
                    .build())
            .build())
    .get();

using Qdrant.Client;
using static Qdrant.Client.Grpc.Conditions;

var client = new QdrantClient("localhost", 6334);

await client.ScrollAsync(collectionName: "{collection_name}", filter: HasId([1, 3, 5, 7, 9, 11]));

import (
  "context"

  "github.com/qdrant/go-client/qdrant"
)

client, err := qdrant.NewClient(&qdrant.Config{
  Host: "localhost",
  Port: 6334,
})

client.Scroll(context.Background(), &qdrant.ScrollPoints{
  CollectionName: "{collection_name}",
  Filter: &qdrant.Filter{
      Must: []*qdrant.Condition{
          qdrant.NewHasID(
              qdrant.NewIDNum(1),
              qdrant.NewIDNum(3),
              qdrant.NewIDNum(5),
              qdrant.NewIDNum(7),
              qdrant.NewIDNum(9),
              qdrant.NewIDNum(11),
          ),
      },
  },
})

Результатом фильтрации будут точки:

[
  { "id": 1, "city": "London", "color": "green" },
  { "id": 3, "city": "London", "color": "blue" },
  { "id": 5, "city": "Moscow", "color": "green" }
]

Has vector (имеет вектор)#

Это условие позволяет фильтровать по наличию указанного именованного вектора на точке.

Например, в коллекции есть два именованных вектора:

PUT /collections/{collection_name}
{
    "vectors": {
        "image": {
            "size": 4,
            "distance": "Dot"
        },
        "text": {
            "size": 8,
            "distance": "Cosine"
        }
    },
    "sparse_vectors": {
        "sparse-image": {},
        "sparse-text": {},
    },
}

Некоторые точки в коллекции могут иметь все векторы, другие могут иметь лишь их подмножество.

Если коллекция не содержит именованных векторов, используйте пустое имя ("").

Пример поиска точек, для которых определен плотный вектор image:

POST /collections/{collection_name}/points/scroll
{
    "filter": {
        "must": [
            { "has_vector": "image" }
        ]
    }
}

from qdrant_client import QdrantClient, models

client = QdrantClient(url="http://localhost:6333")

client.scroll(
    collection_name="{collection_name}",
    scroll_filter=models.Filter(
        must=[
            models.HasVectorCondition(has_vector="image"),
        ],
    ),
)

client.scroll("{collection_name}", {
  filter: {
    must: [
      {
        has_vector: "image",
      },
    ],
  },
});

use qdrant_client::qdrant::{Condition, Filter, ScrollPointsBuilder};
use qdrant_client::Qdrant;

let client = Qdrant::from_url("http://localhost:6334").build()?;
    
client
    .scroll(
        ScrollPointsBuilder::new("{collection_name}")
            .filter(Filter::must([Condition::has_vector("image")])),
    )
    .await?;

import java.util.List;

import static io.qdrant.client.ConditionFactory.hasVector;
import static io.qdrant.client.PointIdFactory.id;

import io.qdrant.client.grpc.Points.Filter;
import io.qdrant.client.grpc.Points.ScrollPoints;

client
    .scrollAsync(
        ScrollPoints.newBuilder()
            .setCollectionName("{collection_name}")
            .setFilter(
                Filter.newBuilder()
                    .addMust(hasVector("image"))
                    .build())
            .build())
    .get();

using Qdrant.Client;
using static Qdrant.Client.Grpc.Conditions;

var client = new QdrantClient("localhost", 6334);

await client.ScrollAsync(collectionName: "{collection_name}", filter: HasVector("image"));

import (
  "context"

  "github.com/qdrant/go-client/qdrant"
)

client, err := qdrant.NewClient(&qdrant.Config{
  Host: "localhost",
  Port: 6334,
})

client.Scroll(context.Background(), &qdrant.ScrollPoints{
  CollectionName: "{collection_name}",
  Filter: &qdrant.Filter{
      Must: []*qdrant.Condition{
          qdrant.NewHasVector(
        "image",
          ),
      },
  },
})