Правила скалярной фильтрации

Обзор

Выражение предиката выводит булево значение. Milvus осуществляет скалярную фильтрацию путем поиска с помощью предикатов. Выражение с предикатом, когда оно оценивается, возвращает либо TRUE, либо FALSE. Ознакомьтесь с Python SDK API Reference для получения инструкций по использованию предикатных выражений.

Правила грамматикиEBNF описывают правила булевых выражений:

Expr = LogicalExpr | NIL
LogicalExpr = LogicalExpr BinaryLogicalOp LogicalExpr 
              | UnaryLogicalOp LogicalExpr
              | "(" LogicalExpr ")"
              | SingleExpr;
BinaryLogicalOp = "&&" | "and" | "||" | "or";
UnaryLogicalOp = "not";
SingleExpr = TermExpr | CompareExpr;
TermExpr = IDENTIFIER "in" ConstantArray;
Constant = INTEGER | FLOAT
ConstantExpr = Constant
               | ConstantExpr BinaryArithOp ConstantExpr
               | UnaryArithOp ConstantExpr;
                                                          
ConstantArray = "[" ConstantExpr { "," ConstantExpr } "]";
UnaryArithOp = "+" | "-"
BinaryArithOp = "+" | "-" | "*" | "/" | "%" | "**";
CompareExpr = IDENTIFIER CmpOp IDENTIFIER
              | IDENTIFIER CmpOp ConstantExpr
              | ConstantExpr CmpOp IDENTIFIER
              | ConstantExpr CmpOpRestricted IDENTIFIER CmpOpRestricted ConstantExpr;
CmpOpRestricted = "<" | "<=";
CmpOp = ">" | ">=" | "<" | "<=" | "=="| "!=";
MatchOp = "like" | "LIKE";
JsonArrayOps = JsonDefs "(" IDENTIFIER "," JsonExpr | JsonArray ")";
JsonArrayDefs = "json_contains" | "JSON_CONTAINS" 
           | "json_contains_all" | "JSON_CONTAINS_ALL" 
           | "json_contains_any" | "JSON_CONTAINS_ANY";
JsonExpr =  Constant | ConstantArray | STRING | BOOLEAN;
JsonArray = "[" JsonExpr { "," JsonExpr } "]";
ArrayOps = ArrayDefs "(" IDENTIFIER "," ArrayExpr | Array ")";
ArrayDefs = "array_contains" | "ARRAY_CONTAINS" 
           | "array_contains_all" | "ARRAY_CONTAINS_ALL" 
           | "array_contains_any" | "ARRAY_CONTAINS_ANY"
           | "array_length"       | "ARRAY_LENGTH";
ArrayExpr =  Constant | ConstantArray | STRING | BOOLEAN;
Array = "[" ArrayExpr { "," ArrayExpr } "]";

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

Условное обозначение	Описание
=	Определение.
,	Конкатенация.
;	Окончание.
|	Альтернация.
{...}	Повторение.
(...)	Группировка.
NIL	Пустой. Выражение может быть пустой строкой.
INTEGER	Целые числа, такие как 1, 2, 3.
FLOAT	Плавающие числа, такие как 1,0, 2,0.
CONST	Целочисленные или плавающие числа.
ИДЕНТИФИКАТОР	Идентификатор. В Milvus IDENTIFIER представляет собой имя поля.
LogicalOp	LogicalOp - это логический оператор, который поддерживает объединение более одной реляционной операции в одном сравнении. Возвращаемое значение LogicalOp - TRUE (1) или FALSE (0). Существует два типа логических операторов, включая BinaryLogicalOps и UnaryLogicalOps.
UnaryLogicalOp	UnaryLogicalOp обозначает унарный логический оператор "не".
BinaryLogicalOp	Бинарные логические операторы, которые выполняют действия над двумя операндами. В сложных выражениях с двумя и более операндами порядок оценки зависит от правил старшинства.
ArithmeticOp	ArithmeticOp, а именно арифметический оператор, выполняет над операндами такие математические операции, как сложение и вычитание.
UnaryArithOp	UnaryArithOp - это арифметический оператор, выполняющий операцию над одним операндом. Отрицательный UnaryArithOp меняет положительное выражение на отрицательное, или наоборот.
BinaryArithOp	BinaryArithOp, а именно бинарный оператор, выполняет операции над двумя операндами. В сложных выражениях с двумя и более операндами порядок оценки зависит от правил старшинства.
CmpOp	CmpOp - это реляционный оператор, выполняющий действия над двумя операндами.
CmpOpRestricted	CmpOpRestricted ограничивается операторами "Меньше чем" и "Равно".
ConstantExpr	ConstantExpr может быть константой или двоичнымArithOp на двух ConstExpr или унарнымArithOp на одном ConstantExpr. Он определяется рекурсивно.
ConstantArray	ConstantArray заключен в квадратные скобки, а ConstantExpr может повторяться в квадратных скобках. ConstArray должен включать хотя бы один ConstantExpr.
TermExpr	TermExpr используется для проверки наличия значения ИДЕНТИФИКАТОРА в массиве ConstantArray. TermExpr обозначается символом "in".
CompareExpr	CompareExpr, то есть выражение сравнения, может быть реляционной операцией над двумя IDENTIFIER, или реляционной операцией над одним IDENTIFIER и одним ConstantExpr, или тернарной операцией над двумя ConstantExpr и одним IDENTIFIER.
SingleExpr	SingleExpr, а именно одно выражение, может быть либо TermExpr, либо CompareExpr.
LogicalExpr	LogicalExpr может быть двоичным LogicalOp над двумя LogicalExpr, или унарным LogicalOp над одним LogicalExpr, или LogicalExpr, сгруппированным в круглых скобках, или SingleExpr. LogicalExpr определяется рекурсивно.
Expr	Expr - аббревиатура, означающая выражение, может быть LogicalExpr или NIL.
MatchOp	MatchOp, а именно оператор соответствия, сравнивает строку со строковой константой или строковой префиксной, инфиксной или суффиксной константой.
JsonArrayOp	JsonOp, а именно оператор JSON, проверяет, содержит ли указанный идентификатор указанные элементы.
ArrayOp	ArrayOp, а именно оператор массива, проверяет, содержит ли указанный идентификатор указанные элементы.

Операторы

Логические операторы

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

Символ	Операция	Пример	Описание
'и' &&	и	expr1 && expr2	Истинно, если оба expr1 и expr2 истинны.
'or' ||	или	expr1 || expr2	Истинно, если истинно либо expr1, либо expr2.

Двоичные арифметические операторы

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

Символ	Операция	Пример	Описание
+	Сложение	a + b	Сложение двух операндов.
-	Вычитание	a - b	Вычитание второго операнда из первого.
*	Умножение	a * b	Умножение двух операндов.
/	Деление	a / b	Разделите первый операнд на второй операнд.
**	Мощность	a ** b	Возведите первый операнд в степень второго операнда.
%	Modulo	a % b	Делит первый операнд на второй операнд и выдает остаток.

Реляционные операторы

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

Символ	Операция	Пример	Описание
<	Меньше, чем	a < b	Истина, если a меньше b.
>	Больше, чем	a > b	Верно, если a больше b.
==	Равно	a == b	Истинно, если a равно b.
!=	Не равно	a != b	Истинно, если a не равно b.
<=	Меньше или равно	a <= b	Верно, если a меньше или равно b.
>=	Больше или равно	a >= b	Истинно, если a больше или равно b.

Старшинство и ассоциативность операторов

В следующей таблице перечислены старшинство и ассоциативность операторов. Операторы перечислены сверху вниз, в порядке убывания старшинства.

Приоритет	Оператор	Описание	Ассоциативность
1	+ -	UnaryArithOp	Слева направо
2	не	UnaryLogicOp	Справа налево
3	**	BinaryArithOp	Слева направо
4	* / %	BinaryArithOp	Слева направо
5	+ -	BinaryArithOp	Слева направо
6	< <= > >=	CmpOp	Слева направо
7	== !=	CmpOp	Слева направо
8	как LIKE	MatchOp	Слева направо
9	json_contains JSON_CONTAINS	JsonArrayOp	Слева направо
9	array_contains ARRAY_CONTAINS	ArrayOp	Слева направо
10	json_contains_all JSON_CONTAINS_ALL	JsonArrayOp	Слева направо
10	array_contains_all ARRAY_CONTAINS_ALL	ArrayOp	Слева направо
11	json_contains_any JSON_CONTAINS_ANY	JsonArrayOp	Слева направо
11	array_contains_any ARRAY_CONTAINS_ANY	ArrayOp	Слева направо
12	array_length ARRAY_LENGTH	ArrayOp	Слева направо
13	&& и	BinaryLogicOp	Слева направо
14	|| или	BinaryLogicOp	Слева направо

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

Если выражение содержит два или более операторов с одинаковым старшинством, первым оценивается оператор, стоящий слева.

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

Скобки могут быть вложены в выражения. Самые внутренние выражения со скобками оцениваются первыми.

Использование

Примеры использования всех доступных булевых выражений в Milvus приведены ниже (int64 представляет скалярное поле, содержащее данные типа INT64, float представляет скалярное поле, содержащее данные типа с плавающей точкой, и VARCHAR представляет скалярное поле, содержащее данные типа VARCHAR):

1. CmpOp

"int64 > 0"

"0 < int64 < 400"

"500 <= int64 < 1000"

VARCHAR > "str1"

2. BinaryLogicalOp и круглые скобки

"(int64 > 0 && int64 < 400) or (int64 > 500 && int64 < 1000)"

3. TermExpr и UnaryLogicOp

"int64 not in [1, 2, 3]"

VARCHAR not in ["str1", "str2"]

4. TermExpr, BinaryLogicalOp и CmpOp (для разных полей)

"int64 in [1, 2, 3] and float != 2"

5. BinaryLogicalOp и CmpOp

"int64 == 0 || int64 == 1 || int64 == 2"

6. CmpOp и UnaryArithOp или BinaryArithOp

"200+300 < int64 <= 500+500"

7. MatchOp

VARCHAR like "prefix%"
VARCHAR like "%suffix"
VARCHAR like "%middle%"
VARCHAR like "_suffix"

8. JsonArrayOp

• JSON_CONTAINS(identifier, JsonExpr)

  Если JSON-выражение оператора JSON_CONTAINS (второй аргумент) представляет собой список, то идентификатор (первый аргумент) должен быть списком списка. В противном случае оператор всегда оценивается как False.

  # {"x": [1,2,3]}
  json_contains(x, 1) # ==> true
  json_contains(x, "a") # ==> false
      
  # {"x": [[1,2,3], [4,5,6], [7,8,9]]}
  json_contains(x, [1,2,3]) # ==> true
  json_contains(x, [3,2,1]) # ==> false
  

• JSON_CONTAINS_ALL(identifier, JsonExpr)

  Выражение JSON в утверждении JSON_CONTAINS_ALL всегда должно быть списком.

  # {"x": [1,2,3,4,5,7,8]}
  json_contains_all(x, [1,2,8]) # ==> true
  json_contains_all(x, [4,5,6]) # ==> false 6 is not exists
  

• JSON_CONTAINS_ANY(identifier, JsonExpr)

  Выражение JSON в утверждении JSON_CONTAINS_ANY всегда должно быть списком. В противном случае оно действует так же, как и JSON_CONTAINS.

  # {"x": [1,2,3,4,5,7,8]}
  json_contains_any(x, [1,2,8]) # ==> true
  json_contains_any(x, [4,5,6]) # ==> true
  json_contains_any(x, [6,9]) # ==> false
  

9. ArrayOp

• ARRAY_CONTAINS(identifier, ArrayExpr)

  Если выражение массива в утверждении ARRAY_CONTAINS (второй аргумент) является списком, то идентификатор (первый аргумент) должен быть списком списка. В противном случае оператор всегда оценивается как False.

  # 'int_array': [1,2,3]
  array_contains(int_array, 1) # ==> true
  array_contains(int_array, "a") # ==> false
  

• ARRAY_CONTAINS_ALL(identifier, ArrayExpr)

  Выражение массива в утверждении ARRAY_CONTAINS_ALL всегда должно быть списком.

  # "int_array": [1,2,3,4,5,7,8]
  array_contains_all(int_array, [1,2,8]) # ==> true
  array_contains_all(int_array, [4,5,6]) # ==> false 6 is not exists
  

• ARRAY_CONTAINS_ANY(identifier, ArrayExpr)

  Выражение массива в операторе ARRAY_CONTAINS_ANY всегда должно быть списком. В противном случае оно действует так же, как и ARRAY_CONTAINS.

  # "int_array": [1,2,3,4,5,7,8]
  array_contains_any(int_array, [1,2,8]) # ==> true
  array_contains_any(int_array, [4,5,6]) # ==> true
  array_contains_any(int_array, [6,9]) # ==> false
  

• ARRAY_LENGTH(identifier)

  Проверьте количество элементов в массиве.

  # "int_array": [1,2,3,4,5,7,8]
  array_length(int_array) # ==> 7
  

Что дальше

Теперь, когда вы знаете, как работают битовые наборы в Milvus, вам также может быть интересно:

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