标量过滤规则

概述

谓词表达式输出一个布尔值。Milvus 通过使用谓词进行标量过滤。谓词表达式在求值时返回 TRUE 或 FALSE。查看 Python SDK API 参考以获取有关使用谓词表达式的指令。

EBNF (opens in a new tab) 语法规则描述了布尔表达式规则：

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 } "]";

下表列出了上述布尔表达式规则中每个符号的描述。

运算符

逻辑运算符

Logical operators perform a comparison between two expressions.

二进制算术运算符

二进制算术运算符包含两个操作数，可以执行基本的算术运算并返回相应的结果。

关系运算符

关系运算符使用符号来检查两个表达式之间的相等性、不等性或相对顺序。

运算符优先级和结合性

下表列出了运算符的优先级和结合性。运算符按照从上到下的顺序列出，优先级从高到低。

表达式通常从左到右进行求值。复杂表达式逐个求值。求值表达式的顺序由使用的运算符的优先级确定。

如果一个表达式中包含两个或多个具有相同优先级的运算符，则首先评估左侧的运算符。

例如，10 / 2 * 5 将被评估为(10 / 2)，然后将结果乘以 5。

当一个较低优先级的操作应该首先处理时，应将其放在括号中。

例如，30 / 2 + 8。这通常被解释为 30 除以 2，然后将 8 加上结果。如果要除以 2 + 8，则应写为 30 / (2 + 8)。

括号可以在表达式中嵌套。最内层的括号表达式最先求值。

用法

Samples of all available boolean expression usage in Milvus are listed as follows (int64 represents the scalar field that contains data of INT64 type, float represents the scalar field that contains data of floating-point type, and VARCHAR represents the scalar field that contains data of VARCHAR type):

1. CmpOp

"int64 > 0"

"0 < int64 < 400"

"500 <= int64 < 1000"

VARCHAR > "str1"

2. BinaryLogicalOp and parentheses

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

3. TermExpr and UnaryLogicOp

Milvus 仅支持通过明确定义的主键删除实体，这仅可以通过 term 表达式 in 实现。

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

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

4. TermExpr, BinaryLogicalOp, and CmpOp (on different fields)

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

5. BinaryLogicalOp and CmpOp

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

6. CmpOp and UnaryArithOp or 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_CONTAINS 语句的 JSON 表达式（第二个参数）为列表，则标识符（第一个参数）应为列表的列表。否则，该语句始终为 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_CONTAINS_ALL 语句中的 JSON 表达式应始终为列表。

  # {"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不存在

• JSON_CONTAINS_ANY(identifier, JsonExpr)

  JSON_CONTAINS_ANY 语句中的 JSON 表达式应始终为列表。否则，它的行为与 JSON_CONTAINS 相同。

ArrayOp

• ARRAY_CONTAINS（identifier，ArrayExpr）

  如果 ARRAY_CONTAINS（第二个参数）语句中的数组表达式是一个列表，则标识符（第一个参数）应该是列表的列表。否则，该语句始终计算为 False。

  # {"x": [1,2,3,4,5,7,8]}
  json包含任何(x，[1,2,8])  # ==> true
  json包含任何(x，[4,5,6])  # ==> true
  json包含任何(x，[6,9])  # ==> false

• ARRAY_CONTAINS_ALL（identifier，ArrayExpr）

  ARRAY_CONTAINS_ALL 语句中的数组表达式应始终是一个列表。

  # "int_array": [1,2,3,4,5,7,8]
  数组包含所有(int_array，[1,2,8])  # ==> true
  数组包含所有(int_array，[4,5,6])  # ==> false 6不存在

• ARRAY_CONTAINS_ANY（identifier，ArrayExpr）

  ARRAY_CONTAINS_ANY 语句中的数组表达式应始终是一个列表。否则，它的作用与 ARRAY_CONTAINS 相同。

  # "int_array": [1,2,3,4,5,7,8]
  数组包含任何(int_array，[1,2,8])  # ==> true
  数组包含任何(int_array，[4,5,6])  # ==> true
  数组包含任何(int_array，[6,9])  # ==> false

• ARRAY_LENGTH（identifier）

  检查数组中元素的数量。

  # "int_array": [1,2,3,4,5,7,8]
  数组长度(int_array)  # ==> 7

What's next

既然你已经知道在 Milvus 中 bitsets 的工作原理，你可能还想要：

• 学习如何进行 多向量搜索。
• 学习如何 使用字符串过滤 (opens in a new tab) 你的搜索结果。
• 学习如何在构建布尔表达式中 使用动态字段。