milvus-io
/
milvus
mirror of https://github.com/milvus-io/milvus.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

feat: [cherry-pick]The expression supports filling elements through templates (#37058) 

issue: #36672 

master pr: #37033 

milvus-proto pr: https://github.com/milvus-io/milvus-proto/pull/332

Signed-off-by: Cai Zhang <cai.zhang@zilliz.com>
pull/37198/head
cai.zhang 2024-10-28 15:17:30 +08:00 committed by GitHub
parent 4cb5b2c3b5
commit 9c0f59488a
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
30 changed files with 2759 additions and 1397 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
go.mod
View File

@ -26,7 +26,7 @@ require (
github.com/grpc-ecosystem/go-grpc-middleware v1.3.0
github.com/klauspost/compress v1.17.9
github.com/mgutz/ansi v0.0.0-20200706080929-d51e80ef957d
github.com/milvus-io/milvus-proto/go-api/v2 v2.4.13
github.com/milvus-io/milvus-proto/go-api/v2 v2.4.14-0.20241025033521-13fc3509ee0b
github.com/minio/minio-go/v7 v7.0.73
github.com/pingcap/log v1.1.1-0.20221015072633-39906604fb81
github.com/prometheus/client_golang v1.14.0

2
go.sum
View File

@ -610,6 +610,8 @@ github.com/milvus-io/gorocksdb v0.0.0-20220624081344-8c5f4212846b h1:TfeY0NxYxZz
github.com/milvus-io/gorocksdb v0.0.0-20220624081344-8c5f4212846b/go.mod h1:iwW+9cWfIzzDseEBCCeDSN5SD16Tidvy8cwQ7ZY8Qj4=
github.com/milvus-io/milvus-proto/go-api/v2 v2.4.13 h1:79fAk5rUFNl7A5RhYUlxcZTHAY31lygULC6QUvpBrUo=
github.com/milvus-io/milvus-proto/go-api/v2 v2.4.13/go.mod h1:/6UT4zZl6awVeXLeE7UGDWZvXj3IWkRsh3mqsn0DiAs=
github.com/milvus-io/milvus-proto/go-api/v2 v2.4.14-0.20241025033521-13fc3509ee0b h1:Q4f3a6Y+HZFEadEx3pUXTZmBwrS3QRvkEHWNd8fjDtI=
github.com/milvus-io/milvus-proto/go-api/v2 v2.4.14-0.20241025033521-13fc3509ee0b/go.mod h1:/6UT4zZl6awVeXLeE7UGDWZvXj3IWkRsh3mqsn0DiAs=
github.com/milvus-io/milvus-storage/go v0.0.0-20231227072638-ebd0b8e56d70 h1:Z+sp64fmAOxAG7mU0dfVOXvAXlwRB0c8a96rIM5HevI=
github.com/milvus-io/milvus-storage/go v0.0.0-20231227072638-ebd0b8e56d70/go.mod h1:GPETMcTZq1gLY1WA6Na5kiNAKnq8SEMMiVKUZrM3sho=
github.com/milvus-io/pulsar-client-go v0.6.10 h1:eqpJjU+/QX0iIhEo3nhOqMNXL+TyInAs1IAHZCrCM/A=

19
internal/parser/planparserv2/Plan.g4
View File

@ -5,10 +5,12 @@ expr:
| FloatingConstant # Floating
| BooleanConstant # Boolean
| StringLiteral # String
| Identifier # Identifier
| (Identifier|Meta) # Identifier
| JSONIdentifier # JSONIdentifier
| LBRACE Identifier RBRACE # TemplateVariable
| '(' expr ')' # Parens
| '[' expr (',' expr)* ','? ']' # Array
| EmptyArray # EmptyArray
| expr LIKE StringLiteral # Like
| expr POW expr # Power
| op = (ADD | SUB | BNOT | NOT) expr # Unary
@ -16,8 +18,7 @@ expr:
| expr op = (MUL | DIV | MOD) expr # MulDivMod
| expr op = (ADD | SUB) expr # AddSub
| expr op = (SHL | SHR) expr # Shift
| expr op = (IN | NIN) ('[' expr (',' expr)* ','? ']') # Term
| expr op = (IN | NIN) EmptyTerm # EmptyTerm
| expr op = NOT? IN expr # Term
| (JSONContains | ArrayContains)'('expr',' expr')' # JSONContains
| (JSONContainsAll | ArrayContainsAll)'('expr',' expr')' # JSONContainsAll
| (JSONContainsAny | ArrayContainsAny)'('expr',' expr')' # JSONContainsAny
@ -42,6 +43,8 @@ expr:
// INT64: 'int64';
// FLOAT: 'float';
// DOUBLE: 'double';
LBRACE: '{';
RBRACE: '}';
LT: '<';
LE: '<=';
@ -71,9 +74,8 @@ OR: '||' | 'or';
BNOT: '~';
NOT: '!' | 'not';
IN: 'in';
NIN: 'not in';
EmptyTerm: '[' (Whitespace | Newline)* ']';
IN: 'in' | 'IN';
EmptyArray: '[' (Whitespace | Newline)* ']';
JSONContains: 'json_contains' | 'JSON_CONTAINS';
JSONContainsAll: 'json_contains_all' | 'JSON_CONTAINS_ALL';
@ -96,10 +98,11 @@ FloatingConstant:
DecimalFloatingConstant
| HexadecimalFloatingConstant;
Identifier: Nondigit (Nondigit | Digit)* | '$meta';
Identifier: Nondigit (Nondigit | Digit)*;
Meta: '$meta';
StringLiteral: EncodingPrefix? ('"' DoubleSCharSequence? '"' | '\'' SingleSCharSequence? '\'');
JSONIdentifier: Identifier('[' (StringLiteral | DecimalConstant) ']')+;
JSONIdentifier: (Identifier | Meta)('[' (StringLiteral | DecimalConstant) ']')+;
fragment EncodingPrefix: 'u8' | 'u' | 'U' | 'L';

4
internal/parser/planparserv2/check_identical_test.go
View File

@ -17,9 +17,9 @@ func TestCheckIdentical(t *testing.T) {
exprStr1 := `not (((Int64Field > 0) and (FloatField <= 20.0)) or ((Int32Field in [1, 2, 3]) and (VarCharField < "str")))`
exprStr2 := `Int32Field in [1, 2, 3]`
expr1, err := ParseExpr(helper, exprStr1)
expr1, err := ParseExpr(helper, exprStr1, nil)
assert.NoError(t, err)
expr2, err := ParseExpr(helper, exprStr2)
expr2, err := ParseExpr(helper, exprStr2, nil)
assert.NoError(t, err)
assert.True(t, CheckPredicatesIdentical(expr1, expr1))

73
internal/parser/planparserv2/convert_field_data_to_generic_value.go Normal file
View File

@ -0,0 +1,73 @@
package planparserv2
import (
"fmt"
"github.com/milvus-io/milvus-proto/go-api/v2/schemapb"
"github.com/milvus-io/milvus/internal/proto/planpb"
)
func ConvertToGenericValue(templateName string, templateValue *schemapb.TemplateValue) (*planpb.GenericValue, error) {
if templateValue == nil {
return nil, fmt.Errorf("expression template variable value is nil, template name: {%s}", templateName)
}
switch templateValue.GetType() {
case schemapb.DataType_Bool:
return &planpb.GenericValue{
Val: &planpb.GenericValue_BoolVal{
BoolVal: templateValue.GetBoolVal(),
},
}, nil
case schemapb.DataType_Int8, schemapb.DataType_Int16, schemapb.DataType_Int32, schemapb.DataType_Int64:
return &planpb.GenericValue{
Val: &planpb.GenericValue_Int64Val{
Int64Val: templateValue.GetInt64Val(),
},
}, nil
case schemapb.DataType_Float, schemapb.DataType_Double:
return &planpb.GenericValue{
Val: &planpb.GenericValue_FloatVal{
FloatVal: templateValue.GetFloatVal(),
},
}, nil
case schemapb.DataType_String, schemapb.DataType_VarChar:
return &planpb.GenericValue{
Val: &planpb.GenericValue_StringVal{
StringVal: templateValue.GetStringVal(),
},
}, nil
case schemapb.DataType_Array:
elements := templateValue.GetArrayVal().GetArray()
arrayValues := make([]*planpb.GenericValue, len(elements))
for i, element := range elements {
arrayElement, err := ConvertToGenericValue(templateName, element)
if err != nil {
return nil, err
}
arrayValues[i] = arrayElement
}
return &planpb.GenericValue{
Val: &planpb.GenericValue_ArrayVal{
ArrayVal: &planpb.Array{
Array: arrayValues,
SameType: templateValue.GetArrayVal().GetSameType(),
ElementType: templateValue.GetArrayVal().GetElementType(),
},
},
}, nil
default:
return nil, fmt.Errorf("expression elements can only be scalars")
}
}
func UnmarshalExpressionValues(input map[string]*schemapb.TemplateValue) (map[string]*planpb.GenericValue, error) {
result := make(map[string]*planpb.GenericValue, len(input))
for name, value := range input {
rv, err := ConvertToGenericValue(name, value)
if err != nil {
return nil, err
}
result[name] = rv
}
return result, nil
}

286
internal/parser/planparserv2/convert_field_data_to_generic_value_test.go Normal file
View File

@ -0,0 +1,286 @@
package planparserv2
import (
"testing"
"github.com/stretchr/testify/assert"
"github.com/milvus-io/milvus-proto/go-api/v2/schemapb"
"github.com/milvus-io/milvus/internal/proto/planpb"
)
type convertTestcase struct {
input map[string]*schemapb.TemplateValue
expect map[string]*planpb.GenericValue
}
func Test_ConvertToGenericValue(t *testing.T) {
tests := []convertTestcase{
{
input: map[string]*schemapb.TemplateValue{
"bool": {
Type: schemapb.DataType_Bool,
Val: &schemapb.TemplateValue_BoolVal{
BoolVal: false,
},
},
},
expect: map[string]*planpb.GenericValue{
"bool": {
Val: &planpb.GenericValue_BoolVal{
BoolVal: false,
},
},
},
},
{
input: map[string]*schemapb.TemplateValue{
"int": {
Type: schemapb.DataType_Int64,
Val: &schemapb.TemplateValue_Int64Val{
Int64Val: 999,
},
},
},
expect: map[string]*planpb.GenericValue{
"int": {
Val: &planpb.GenericValue_Int64Val{
Int64Val: 999,
},
},
},
},
{
input: map[string]*schemapb.TemplateValue{
"float": {
Type: schemapb.DataType_Float,
Val: &schemapb.TemplateValue_FloatVal{
FloatVal: 55.55,
},
},
},
expect: map[string]*planpb.GenericValue{
"float": {
Val: &planpb.GenericValue_FloatVal{
FloatVal: 55.55,
},
},
},
},
{
input: map[string]*schemapb.TemplateValue{
"string": {
Type: schemapb.DataType_VarChar,
Val: &schemapb.TemplateValue_StringVal{
StringVal: "abc",
},
},
},
expect: map[string]*planpb.GenericValue{
"string": {
Val: &planpb.GenericValue_StringVal{
StringVal: "abc",
},
},
},
},
{
input: map[string]*schemapb.TemplateValue{
"array": {
Type: schemapb.DataType_Array,
Val: &schemapb.TemplateValue_ArrayVal{
ArrayVal: &schemapb.TemplateArrayValue{
Array: []*schemapb.TemplateValue{
{
Type: schemapb.DataType_Int64,
Val: &schemapb.TemplateValue_Int64Val{
Int64Val: 111,
},
},
{
Type: schemapb.DataType_Int64,
Val: &schemapb.TemplateValue_Int64Val{
Int64Val: 222,
},
},
{
Type: schemapb.DataType_Int64,
Val: &schemapb.TemplateValue_Int64Val{
Int64Val: 333,
},
},
},
SameType: true,
ElementType: schemapb.DataType_Int64,
},
},
},
},
expect: map[string]*planpb.GenericValue{
"array": {
Val: &planpb.GenericValue_ArrayVal{
ArrayVal: &planpb.Array{
Array: []*planpb.GenericValue{
{
Val: &planpb.GenericValue_Int64Val{
Int64Val: 111,
},
},
{
Val: &planpb.GenericValue_Int64Val{
Int64Val: 222,
},
},
{
Val: &planpb.GenericValue_Int64Val{
Int64Val: 333,
},
},
},
SameType: true,
ElementType: schemapb.DataType_Int64,
},
},
},
},
},
{
input: map[string]*schemapb.TemplateValue{
"not_same_array": {
Type: schemapb.DataType_Array,
Val: &schemapb.TemplateValue_ArrayVal{
ArrayVal: &schemapb.TemplateArrayValue{
Array: []*schemapb.TemplateValue{
{
Type: schemapb.DataType_Int64,
Val: &schemapb.TemplateValue_Int64Val{
Int64Val: 111,
},
},
{
Type: schemapb.DataType_Float,
Val: &schemapb.TemplateValue_FloatVal{
FloatVal: 222.222,
},
},
{
Type: schemapb.DataType_Bool,
Val: &schemapb.TemplateValue_BoolVal{
BoolVal: true,
},
},
{
Type: schemapb.DataType_VarChar,
Val: &schemapb.TemplateValue_StringVal{
StringVal: "abc",
},
},
},
},
},
},
},
expect: map[string]*planpb.GenericValue{
"not_same_array": {
Val: &planpb.GenericValue_ArrayVal{
ArrayVal: &planpb.Array{
Array: []*planpb.GenericValue{
{
Val: &planpb.GenericValue_Int64Val{
Int64Val: 111,
},
},
{
Val: &planpb.GenericValue_FloatVal{
FloatVal: 222.222,
},
},
{
Val: &planpb.GenericValue_BoolVal{
BoolVal: true,
},
},
{
Val: &planpb.GenericValue_StringVal{
StringVal: "abc",
},
},
},
},
},
},
},
},
}
for _, tt := range tests {
output, err := UnmarshalExpressionValues(tt.input)
assert.Nil(t, err)
assert.EqualValues(t, tt.expect, output)
}
}
func generateExpressionFieldData(dataType schemapb.DataType, data interface{}) *schemapb.TemplateValue {
switch dataType {
case schemapb.DataType_Bool:
return &schemapb.TemplateValue{
Type: dataType,
Val: &schemapb.TemplateValue_BoolVal{
BoolVal: data.(bool),
},
}
case schemapb.DataType_Int8, schemapb.DataType_Int16, schemapb.DataType_Int32, schemapb.DataType_Int64:
return &schemapb.TemplateValue{
Type: dataType,
Val: &schemapb.TemplateValue_Int64Val{
Int64Val: data.(int64),
},
}
case schemapb.DataType_Float, schemapb.DataType_Double:
return &schemapb.TemplateValue{
Type: dataType,
Val: &schemapb.TemplateValue_FloatVal{
FloatVal: data.(float64),
},
}
case schemapb.DataType_String, schemapb.DataType_VarChar:
return &schemapb.TemplateValue{
Type: dataType,
Val: &schemapb.TemplateValue_StringVal{
StringVal: data.(string),
},
}
case schemapb.DataType_Array:
// Handle array data here
// Assume the inner data is already in an appropriate format.
// Placeholder for array implementation.
// You might want to define a recursive approach based on the data structure.
value := data.([]interface{})
arrayData := make([]*schemapb.TemplateValue, len(value))
elementType := schemapb.DataType_None
sameType := true
for i, v := range value {
element := v.(*schemapb.TemplateValue)
arrayData[i] = element
if elementType == schemapb.DataType_None {
elementType = element.GetType()
} else if elementType != element.GetType() {
sameType = false
elementType = schemapb.DataType_JSON
}
}
return &schemapb.TemplateValue{
Type: dataType,
Val: &schemapb.TemplateValue_ArrayVal{
ArrayVal: &schemapb.TemplateArrayValue{
Array: arrayData,
ElementType: elementType,
SameType: sameType,
},
},
}
default:
return nil
}
}

227
internal/parser/planparserv2/fill_expression_value.go Normal file
View File

@ -0,0 +1,227 @@
package planparserv2
import (
"fmt"
"github.com/milvus-io/milvus-proto/go-api/v2/schemapb"
"github.com/milvus-io/milvus/internal/proto/planpb"
"github.com/milvus-io/milvus/pkg/util/typeutil"
)
func FillExpressionValue(expr *planpb.Expr, templateValues map[string]*planpb.GenericValue) error {
if !expr.GetIsTemplate() {
return nil
}
switch e := expr.GetExpr().(type) {
case *planpb.Expr_TermExpr:
return FillTermExpressionValue(e.TermExpr, templateValues)
case *planpb.Expr_UnaryExpr:
return FillExpressionValue(e.UnaryExpr.GetChild(), templateValues)
case *planpb.Expr_BinaryExpr:
if err := FillExpressionValue(e.BinaryExpr.GetLeft(), templateValues); err != nil {
return err
}
return FillExpressionValue(e.BinaryExpr.GetRight(), templateValues)
case *planpb.Expr_UnaryRangeExpr:
return FillUnaryRangeExpressionValue(e.UnaryRangeExpr, templateValues)
case *planpb.Expr_BinaryRangeExpr:
return FillBinaryRangeExpressionValue(e.BinaryRangeExpr, templateValues)
case *planpb.Expr_BinaryArithOpEvalRangeExpr:
return FillBinaryArithOpEvalRangeExpressionValue(e.BinaryArithOpEvalRangeExpr, templateValues)
case *planpb.Expr_BinaryArithExpr:
if err := FillExpressionValue(e.BinaryArithExpr.GetLeft(), templateValues); err != nil {
return err
}
return FillExpressionValue(e.BinaryArithExpr.GetRight(), templateValues)
case *planpb.Expr_JsonContainsExpr:
return FillJSONContainsExpressionValue(e.JsonContainsExpr, templateValues)
default:
return fmt.Errorf("this expression no need to fill placeholder with expr type: %T", e)
}
}
func FillTermExpressionValue(expr *planpb.TermExpr, templateValues map[string]*planpb.GenericValue) error {
value, ok := templateValues[expr.GetTemplateVariableName()]
if !ok && expr.GetValues() == nil {
return fmt.Errorf("the value of expression template variable name {%s} is not found", expr.GetTemplateVariableName())
}
if value == nil || value.GetArrayVal() == nil {
return fmt.Errorf("the value of term expression template variable {%s} is not array", expr.GetTemplateVariableName())
}
dataType := expr.GetColumnInfo().GetDataType()
if typeutil.IsArrayType(dataType) {
if len(expr.GetColumnInfo().GetNestedPath()) != 0 {
dataType = expr.GetColumnInfo().GetElementType()
}
}
array := value.GetArrayVal().GetArray()
values := make([]*planpb.GenericValue, len(array))
for i, e := range array {
castedValue, err := castValue(dataType, e)
if err != nil {
return err
}
values[i] = castedValue
}
expr.Values = values
return nil
}
func FillUnaryRangeExpressionValue(expr *planpb.UnaryRangeExpr, templateValues map[string]*planpb.GenericValue) error {
value, ok := templateValues[expr.GetTemplateVariableName()]
if !ok {
return fmt.Errorf("the value of expression template variable name {%s} is not found", expr.GetTemplateVariableName())
}
dataType := expr.GetColumnInfo().GetDataType()
if typeutil.IsArrayType(dataType) {
if len(expr.GetColumnInfo().GetNestedPath()) != 0 {
dataType = expr.GetColumnInfo().GetElementType()
}
}
castedValue, err := castValue(dataType, value)
if err != nil {
return err
}
expr.Value = castedValue
return nil
}
func FillBinaryRangeExpressionValue(expr *planpb.BinaryRangeExpr, templateValues map[string]*planpb.GenericValue) error {
var ok bool
dataType := expr.GetColumnInfo().GetDataType()
if typeutil.IsArrayType(dataType) && len(expr.GetColumnInfo().GetNestedPath()) != 0 {
dataType = expr.GetColumnInfo().GetElementType()
}
lowerValue := expr.GetLowerValue()
if lowerValue == nil || expr.GetLowerTemplateVariableName() != "" {
lowerValue, ok = templateValues[expr.GetLowerTemplateVariableName()]
if !ok {
return fmt.Errorf("the lower value of expression template variable name {%s} is not found", expr.GetLowerTemplateVariableName())
}
castedLowerValue, err := castValue(dataType, lowerValue)
if err != nil {
return err
}
expr.LowerValue = castedLowerValue
}
upperValue := expr.GetUpperValue()
if upperValue == nil || expr.GetUpperTemplateVariableName() != "" {
upperValue, ok = templateValues[expr.GetUpperTemplateVariableName()]
if !ok {
return fmt.Errorf("the upper value of expression template variable name {%s} is not found", expr.GetUpperTemplateVariableName())
}
castedUpperValue, err := castValue(dataType, upperValue)
if err != nil {
return err
}
expr.UpperValue = castedUpperValue
}
if !(expr.GetLowerInclusive() && expr.GetUpperInclusive()) {
if getGenericValue(GreaterEqual(lowerValue, upperValue)).GetBoolVal() {
return fmt.Errorf("invalid range: lowerbound is greater than upperbound")
}
} else {
if getGenericValue(Greater(lowerValue, upperValue)).GetBoolVal() {
return fmt.Errorf("invalid range: lowerbound is greater than upperbound")
}
}
return nil
}
func FillBinaryArithOpEvalRangeExpressionValue(expr *planpb.BinaryArithOpEvalRangeExpr, templateValues map[string]*planpb.GenericValue) error {
var dataType schemapb.DataType
var err error
var ok bool
operand := expr.GetRightOperand()
if operand == nil || expr.GetOperandTemplateVariableName() != "" {
operand, ok = templateValues[expr.GetOperandTemplateVariableName()]
if !ok {
return fmt.Errorf("the right operand value of expression template variable name {%s} is not found", expr.GetOperandTemplateVariableName())
}
}
operandExpr := toValueExpr(operand)
lDataType, rDataType := expr.GetColumnInfo().GetDataType(), operandExpr.dataType
if typeutil.IsArrayType(expr.GetColumnInfo().GetDataType()) {
lDataType = expr.GetColumnInfo().GetElementType()
}
if err = checkValidModArith(expr.GetArithOp(), expr.GetColumnInfo().GetDataType(), expr.GetColumnInfo().GetElementType(),
rDataType, schemapb.DataType_None); err != nil {
return err
}
if operand.GetArrayVal() != nil {
return fmt.Errorf("can not comparisons array directly")
}
dataType, err = getTargetType(lDataType, rDataType)
if err != nil {
return err
}
castedOperand, err := castValue(dataType, operand)
if err != nil {
return err
}
expr.RightOperand = castedOperand
value := expr.GetValue()
if expr.GetValue() == nil || expr.GetValueTemplateVariableName() != "" {
value, ok = templateValues[expr.GetValueTemplateVariableName()]
if !ok {
return fmt.Errorf("the value of expression template variable name {%s} is not found", expr.GetValueTemplateVariableName())
}
}
castedValue, err := castValue(dataType, value)
if err != nil {
return err
}
expr.Value = castedValue
return nil
}
func FillJSONContainsExpressionValue(expr *planpb.JSONContainsExpr, templateValues map[string]*planpb.GenericValue) error {
if expr.GetElements() != nil && expr.GetTemplateVariableName() == "" {
return nil
}
value, ok := templateValues[expr.GetTemplateVariableName()]
if !ok {
return fmt.Errorf("the value of expression template variable name {%s} is not found", expr.GetTemplateVariableName())
}
if err := checkContainsElement(toColumnExpr(expr.GetColumnInfo()), expr.GetOp(), value); err != nil {
return err
}
dataType := expr.GetColumnInfo().GetDataType()
if typeutil.IsArrayType(dataType) {
dataType = expr.GetColumnInfo().GetElementType()
}
if expr.GetOp() == planpb.JSONContainsExpr_Contains {
castedValue, err := castValue(dataType, value)
if err != nil {
return err
}
expr.Elements = append(expr.Elements, castedValue)
} else {
for _, e := range value.GetArrayVal().GetArray() {
castedValue, err := castValue(dataType, e)
if err != nil {
return err
}
expr.Elements = append(expr.Elements, castedValue)
}
}
return nil
}

568
internal/parser/planparserv2/fill_expression_value_test.go Normal file
View File

@ -0,0 +1,568 @@
package planparserv2
import (
"encoding/json"
"fmt"
"testing"
"github.com/stretchr/testify/suite"
"github.com/milvus-io/milvus-proto/go-api/v2/schemapb"
"github.com/milvus-io/milvus/internal/proto/planpb"
)
type FillExpressionValueSuite struct {
suite.Suite
}
func TestFillExpressionValue(t *testing.T) {
suite.Run(t, new(FillExpressionValueSuite))
}
type testcase struct {
expr string
values map[string]*schemapb.TemplateValue
}
func (s *FillExpressionValueSuite) jsonMarshal(v interface{}) []byte {
r, err := json.Marshal(v)
s.NoError(err)
return r
}
func (s *FillExpressionValueSuite) TestTermExpr() {
s.Run("normal case", func() {
testcases := []testcase{
{`Int64Field in {age}`, map[string]*schemapb.TemplateValue{
"age": generateExpressionFieldData(schemapb.DataType_Array, []interface{}{
generateExpressionFieldData(schemapb.DataType_Int64, int64(1)),
generateExpressionFieldData(schemapb.DataType_Int64, int64(2)),
generateExpressionFieldData(schemapb.DataType_Int64, int64(3)),
generateExpressionFieldData(schemapb.DataType_Int64, int64(4)),
}),
}},
{`FloatField in {age}`, map[string]*schemapb.TemplateValue{
"age": generateExpressionFieldData(schemapb.DataType_Array, []interface{}{
generateExpressionFieldData(schemapb.DataType_Float, 1.1),
generateExpressionFieldData(schemapb.DataType_Float, 2.2),
generateExpressionFieldData(schemapb.DataType_Float, 3.3),
generateExpressionFieldData(schemapb.DataType_Float, 4.4),
}),
}},
{`A in {list}`, map[string]*schemapb.TemplateValue{
"list": generateExpressionFieldData(schemapb.DataType_Array, []interface{}{
generateExpressionFieldData(schemapb.DataType_Int64, int64(1)),
generateExpressionFieldData(schemapb.DataType_Float, 2.2),
generateExpressionFieldData(schemapb.DataType_String, "abc"),
generateExpressionFieldData(schemapb.DataType_Bool, false),
}),
}},
{`ArrayField in {list}`, map[string]*schemapb.TemplateValue{
"list": generateExpressionFieldData(schemapb.DataType_Array, []interface{}{
generateExpressionFieldData(schemapb.DataType_Array, []interface{}{
generateExpressionFieldData(schemapb.DataType_Int64, int64(1)),
generateExpressionFieldData(schemapb.DataType_Int64, int64(2)),
generateExpressionFieldData(schemapb.DataType_Int64, int64(3)),
}),
generateExpressionFieldData(schemapb.DataType_Array, []interface{}{
generateExpressionFieldData(schemapb.DataType_Int64, int64(4)),
generateExpressionFieldData(schemapb.DataType_Int64, int64(5)),
generateExpressionFieldData(schemapb.DataType_Int64, int64(6)),
}),
generateExpressionFieldData(schemapb.DataType_Array, []interface{}{
generateExpressionFieldData(schemapb.DataType_Int64, int64(7)),
generateExpressionFieldData(schemapb.DataType_Int64, int64(8)),
generateExpressionFieldData(schemapb.DataType_Int64, int64(9)),
}),
}),
}},
{`ArrayField[0] in {list}`, map[string]*schemapb.TemplateValue{
"list": generateExpressionFieldData(schemapb.DataType_Array, []interface{}{
generateExpressionFieldData(schemapb.DataType_Int64, int64(1)),
generateExpressionFieldData(schemapb.DataType_Int64, int64(2)),
generateExpressionFieldData(schemapb.DataType_Int64, int64(3)),
}),
}},
{`Int64Field in {empty_list}`, map[string]*schemapb.TemplateValue{
"empty_list": generateExpressionFieldData(schemapb.DataType_Array, []interface{}{}),
}},
}
schemaH := newTestSchemaHelper(s.T())
for _, c := range testcases {
plan, err := CreateSearchPlan(schemaH, c.expr, "FloatVectorField", &planpb.QueryInfo{
Topk: 0,
MetricType: "",
SearchParams: "",
RoundDecimal: 0,
}, c.values)
s.NoError(err)
s.NotNil(plan)
}
})
s.Run("failed case", func() {
testcases := []testcase{
{`Int64Field in {age}`, map[string]*schemapb.TemplateValue{
"age": generateExpressionFieldData(schemapb.DataType_Array, []interface{}{
generateExpressionFieldData(schemapb.DataType_String, "abc"),
generateExpressionFieldData(schemapb.DataType_String, "def"),
}),
}},
{`StringField in {list}`, map[string]*schemapb.TemplateValue{
"list": generateExpressionFieldData(schemapb.DataType_Array, []interface{}{
generateExpressionFieldData(schemapb.DataType_Int64, int64(1)),
generateExpressionFieldData(schemapb.DataType_String, "abc"),
generateExpressionFieldData(schemapb.DataType_Float, 2.2),
generateExpressionFieldData(schemapb.DataType_Bool, false),
}),
}},
{"ArrayField[0] in {list}", map[string]*schemapb.TemplateValue{
"list": generateExpressionFieldData(schemapb.DataType_Array, []interface{}{
generateExpressionFieldData(schemapb.DataType_Int64, int64(1)),
generateExpressionFieldData(schemapb.DataType_String, "abc"),
generateExpressionFieldData(schemapb.DataType_Float, 3.2),
}),
}},
{"Int64Field not in {not_list}", map[string]*schemapb.TemplateValue{
"not_list": generateExpressionFieldData(schemapb.DataType_Int64, int64(33)),
}},
}
schemaH := newTestSchemaHelper(s.T())
for _, c := range testcases {
plan, err := CreateSearchPlan(schemaH, c.expr, "FloatVectorField", &planpb.QueryInfo{
Topk: 0,
MetricType: "",
SearchParams: "",
RoundDecimal: 0,
}, c.values)
s.Error(err)
s.Nil(plan)
fmt.Println(plan)
}
})
}
func (s *FillExpressionValueSuite) TestUnaryRange() {
s.Run("normal case", func() {
testcases := []testcase{
{`Int64Field == 10`, nil},
{`Int64Field > {target}`, map[string]*schemapb.TemplateValue{
"target": generateExpressionFieldData(schemapb.DataType_Int64, int64(11)),
}},
{`FloatField < {target}`, map[string]*schemapb.TemplateValue{
"target": generateExpressionFieldData(schemapb.DataType_Float, float64(12.3)),
}},
{`DoubleField != {target}`, map[string]*schemapb.TemplateValue{
"target": generateExpressionFieldData(schemapb.DataType_Double, 3.5),
}},
{`ArrayField[0] >= {target}`, map[string]*schemapb.TemplateValue{
"target": generateExpressionFieldData(schemapb.DataType_Int64, int64(3)),
}},
{`BoolField == {bool}`, map[string]*schemapb.TemplateValue{
"bool": generateExpressionFieldData(schemapb.DataType_Bool, false),
}},
{`{str} != StringField`, map[string]*schemapb.TemplateValue{
"str": generateExpressionFieldData(schemapb.DataType_String, "abc"),
}},
{`{target} > Int64Field`, map[string]*schemapb.TemplateValue{
"target": generateExpressionFieldData(schemapb.DataType_Int64, int64(11)),
}},
}
schemaH := newTestSchemaHelper(s.T())
for _, c := range testcases {
plan, err := CreateSearchPlan(schemaH, c.expr, "FloatVectorField", &planpb.QueryInfo{
Topk: 0,
MetricType: "",
SearchParams: "",
RoundDecimal: 0,
}, c.values)
s.NoError(err)
s.NotNil(plan)
s.NotNil(plan.GetVectorAnns())
s.NotNil(plan.GetVectorAnns().GetPredicates())
}
})
s.Run("failed case", func() {
testcases := []testcase{
{`Int64Field == 10.5`, nil},
{`Int64Field > {target}`, map[string]*schemapb.TemplateValue{
"target": generateExpressionFieldData(schemapb.DataType_Double, 11.2),
}},
{`FloatField < {target}`, map[string]*schemapb.TemplateValue{
"target": generateExpressionFieldData(schemapb.DataType_String, "abc"),
}},
{`DoubleField != {target}`, map[string]*schemapb.TemplateValue{
"target": generateExpressionFieldData(schemapb.DataType_Bool, false),
}},
{`ArrayField[0] >= {target}`, map[string]*schemapb.TemplateValue{
"target": generateExpressionFieldData(schemapb.DataType_Double, 3.5),
}},
{`BoolField == {bool}`, map[string]*schemapb.TemplateValue{
"bool": generateExpressionFieldData(schemapb.DataType_String, "abc"),
}},
{`{str} != StringField`, map[string]*schemapb.TemplateValue{
"str": generateExpressionFieldData(schemapb.DataType_Int64, int64(5)),
}},
{`{int} != StringField`, map[string]*schemapb.TemplateValue{
"int": generateExpressionFieldData(schemapb.DataType_Int64, int64(5)),
}},
}
schemaH := newTestSchemaHelper(s.T())
for _, c := range testcases {
plan, err := CreateSearchPlan(schemaH, c.expr, "FloatVectorField", &planpb.QueryInfo{
Topk: 0,
MetricType: "",
SearchParams: "",
RoundDecimal: 0,
}, c.values)
s.Error(err)
s.Nil(plan)
}
})
}
func (s *FillExpressionValueSuite) TestBinaryRange() {
s.Run("normal case", func() {
testcases := []testcase{
{`10 < Int64Field < 20`, nil},
{`{max} > Int64Field > {min}`, map[string]*schemapb.TemplateValue{
"min": generateExpressionFieldData(schemapb.DataType_Int64, int64(11)),
"max": generateExpressionFieldData(schemapb.DataType_Int64, int64(22)),
}},
{`{min} <= FloatField <= {max}`, map[string]*schemapb.TemplateValue{
"min": generateExpressionFieldData(schemapb.DataType_Float, float64(11)),
"max": generateExpressionFieldData(schemapb.DataType_Float, float64(22)),
}},
{`{min} < DoubleField < {max}`, map[string]*schemapb.TemplateValue{
"min": generateExpressionFieldData(schemapb.DataType_Double, float64(11)),
"max": generateExpressionFieldData(schemapb.DataType_Double, float64(22)),
}},
{`{max} >= ArrayField[0] >= {min}`, map[string]*schemapb.TemplateValue{
"min": generateExpressionFieldData(schemapb.DataType_Int64, int64(11)),
"max": generateExpressionFieldData(schemapb.DataType_Int64, int64(22)),
}},
{`{max} > Int64Field >= 10`, map[string]*schemapb.TemplateValue{
"max": generateExpressionFieldData(schemapb.DataType_Int64, int64(22)),
}},
{`30 >= Int64Field > {min}`, map[string]*schemapb.TemplateValue{
"min": generateExpressionFieldData(schemapb.DataType_Int64, int64(11)),
}},
{`10 < Int64Field <= {max}`, map[string]*schemapb.TemplateValue{
"max": generateExpressionFieldData(schemapb.DataType_Int64, int64(22)),
}},
{`{min} <= Int64Field < 20`, map[string]*schemapb.TemplateValue{
"min": generateExpressionFieldData(schemapb.DataType_Int64, int64(11)),
}},
}
schemaH := newTestSchemaHelper(s.T())
for _, c := range testcases {
plan, err := CreateSearchPlan(schemaH, c.expr, "FloatVectorField", &planpb.QueryInfo{
Topk: 0,
MetricType: "",
SearchParams: "",
RoundDecimal: 0,
}, c.values)
s.NoError(err)
s.NotNil(plan)
s.NotNil(plan.GetVectorAnns())
s.NotNil(plan.GetVectorAnns().GetPredicates())
}
})
s.Run("failed case", func() {
testcases := []testcase{
{`10 < Int64Field < 20.5`, nil},
{`{max} > Int64Field > {min}`, map[string]*schemapb.TemplateValue{
"min": generateExpressionFieldData(schemapb.DataType_Int64, int64(11)),
"max": generateExpressionFieldData(schemapb.DataType_Double, 22.5),
}},
{`{min} <= FloatField <= {max}`, map[string]*schemapb.TemplateValue{
"min": generateExpressionFieldData(schemapb.DataType_String, "abc"),
"max": generateExpressionFieldData(schemapb.DataType_Int64, int64(11)),
}},
{`{min} < DoubleField < {max}`, map[string]*schemapb.TemplateValue{
"min": generateExpressionFieldData(schemapb.DataType_Int64, int64(33)),
"max": generateExpressionFieldData(schemapb.DataType_Int64, int64(22)),
}},
{`{max} >= ArrayField[0] >= {min}`, map[string]*schemapb.TemplateValue{
"min": generateExpressionFieldData(schemapb.DataType_Double, 11.5),
"max": generateExpressionFieldData(schemapb.DataType_Int64, int64(22)),
}},
{`{max} >= Int64Field >= {min}`, map[string]*schemapb.TemplateValue{
"max": generateExpressionFieldData(schemapb.DataType_Int64, int64(22)),
}},
{`{max} > Int64Field`, map[string]*schemapb.TemplateValue{
"max": generateExpressionFieldData(schemapb.DataType_Bool, false),
}},
{`{$meta} > Int64Field`, map[string]*schemapb.TemplateValue{
"$meta": generateExpressionFieldData(schemapb.DataType_Int64, int64(22)),
}},
}
schemaH := newTestSchemaHelper(s.T())
for _, c := range testcases {
plan, err := CreateSearchPlan(schemaH, c.expr, "FloatVectorField", &planpb.QueryInfo{
Topk: 0,
MetricType: "",
SearchParams: "",
RoundDecimal: 0,
}, c.values)
s.Error(err)
s.Nil(plan)
}
})
}
func (s *FillExpressionValueSuite) TestBinaryArithOpEvalRange() {
s.Run("normal case", func() {
testcases := []testcase{
{`Int64Field + 5.5 == 10.5`, nil},
{`Int64Field - {offset} >= {target}`, map[string]*schemapb.TemplateValue{
"offset": generateExpressionFieldData(schemapb.DataType_Double, 3.5),
"target": generateExpressionFieldData(schemapb.DataType_Double, 11.5),
}},
{`Int64Field * 3.5 <= {target}`, map[string]*schemapb.TemplateValue{
"target": generateExpressionFieldData(schemapb.DataType_Double, 11.5),
}},
{`Int64Field / {offset} > 11.5`, map[string]*schemapb.TemplateValue{
"offset": generateExpressionFieldData(schemapb.DataType_Double, 3.5),
}},
{`ArrayField[0] % {offset} < 11`, map[string]*schemapb.TemplateValue{
"offset": generateExpressionFieldData(schemapb.DataType_Int64, int64(3)),
}},
}
schemaH := newTestSchemaHelper(s.T())
for _, c := range testcases {
plan, err := CreateSearchPlan(schemaH, c.expr, "FloatVectorField", &planpb.QueryInfo{
Topk: 0,
MetricType: "",
SearchParams: "",
RoundDecimal: 0,
}, c.values)
s.NoError(err)
s.NotNil(plan)
s.NotNil(plan.GetVectorAnns())
s.NotNil(plan.GetVectorAnns().GetPredicates())
}
})
s.Run("failed case", func() {
testcases := []testcase{
{`Int64Field + 6 == 12.5`, nil},
{`Int64Field - {offset} == {target}`, map[string]*schemapb.TemplateValue{
"offset": generateExpressionFieldData(schemapb.DataType_Int64, int64(4)),
"target": generateExpressionFieldData(schemapb.DataType_Double, 13.5),
}},
{`Int64Field * 6 == {target}`, map[string]*schemapb.TemplateValue{
"target": generateExpressionFieldData(schemapb.DataType_Double, 13.5),
}},
{`Int64Field / {offset} == 11.5`, map[string]*schemapb.TemplateValue{
"offset": generateExpressionFieldData(schemapb.DataType_Int64, int64(6)),
}},
{`Int64Field % {offset} < 11`, map[string]*schemapb.TemplateValue{
"offset": generateExpressionFieldData(schemapb.DataType_Double, 3.5),
}},
{`Int64Field + {offset} < {target}`, map[string]*schemapb.TemplateValue{
"target": generateExpressionFieldData(schemapb.DataType_Double, 3.5),
}},
{`Int64Field + {offset} < {target}`, map[string]*schemapb.TemplateValue{
"offset": generateExpressionFieldData(schemapb.DataType_String, "abc"),
"target": generateExpressionFieldData(schemapb.DataType_Int64, int64(15)),
}},
{`Int64Field + {offset} < {target}`, map[string]*schemapb.TemplateValue{
"offset": generateExpressionFieldData(schemapb.DataType_Int64, int64(15)),
"target": generateExpressionFieldData(schemapb.DataType_String, "def"),
}},
{`ArrayField + {offset} < {target}`, map[string]*schemapb.TemplateValue{
"offset": generateExpressionFieldData(schemapb.DataType_Double, 3.5),
"target": generateExpressionFieldData(schemapb.DataType_Int64, int64(5)),
}},
{`ArrayField[0] + {offset} < {target}`, map[string]*schemapb.TemplateValue{
"offset": generateExpressionFieldData(schemapb.DataType_Array, []interface{}{
generateExpressionFieldData(schemapb.DataType_Int64, int64(1)),
generateExpressionFieldData(schemapb.DataType_Int64, int64(2)),
generateExpressionFieldData(schemapb.DataType_Int64, int64(3)),
}),
"target": generateExpressionFieldData(schemapb.DataType_Int64, int64(5)),
}},
}
schemaH := newTestSchemaHelper(s.T())
for _, c := range testcases {
plan, err := CreateSearchPlan(schemaH, c.expr, "FloatVectorField", &planpb.QueryInfo{
Topk: 0,
MetricType: "",
SearchParams: "",
RoundDecimal: 0,
}, c.values)
s.Error(err)
s.Nil(plan)
}
})
}
func (s *FillExpressionValueSuite) TestJSONContainsExpression() {
s.Run("normal case", func() {
testcases := []testcase{
{`json_contains(A, 5)`, nil},
{`json_contains(A, {age})`, map[string]*schemapb.TemplateValue{
"age": generateExpressionFieldData(schemapb.DataType_Int64, int64(18)),
}},
{`json_contains(A, {str})`, map[string]*schemapb.TemplateValue{
"str": generateExpressionFieldData(schemapb.DataType_String, "abc"),
}},
{`json_contains(A, {bool})`, map[string]*schemapb.TemplateValue{
"bool": generateExpressionFieldData(schemapb.DataType_Bool, false),
}},
{`json_contains_any(JSONField, {array})`, map[string]*schemapb.TemplateValue{
"array": generateExpressionFieldData(schemapb.DataType_Array, []interface{}{
generateExpressionFieldData(schemapb.DataType_Int64, int64(1)),
generateExpressionFieldData(schemapb.DataType_String, "abc"),
generateExpressionFieldData(schemapb.DataType_Double, 2.2),
generateExpressionFieldData(schemapb.DataType_Bool, false),
}),
}},
{`json_contains_any(JSONField, {array})`, map[string]*schemapb.TemplateValue{
"array": generateExpressionFieldData(schemapb.DataType_Array, []interface{}{
generateExpressionFieldData(schemapb.DataType_Int64, int64(1)),
generateExpressionFieldData(schemapb.DataType_Int64, int64(2)),
generateExpressionFieldData(schemapb.DataType_Int64, int64(3)),
generateExpressionFieldData(schemapb.DataType_Int64, int64(4)),
}),
}},
{`json_contains_any(JSONField["A"], {array})`, map[string]*schemapb.TemplateValue{
"array": generateExpressionFieldData(schemapb.DataType_Array, []interface{}{
generateExpressionFieldData(schemapb.DataType_Int64, int64(1)),
generateExpressionFieldData(schemapb.DataType_Int64, int64(2)),
generateExpressionFieldData(schemapb.DataType_Int64, int64(3)),
generateExpressionFieldData(schemapb.DataType_Int64, int64(4)),
}),
}},
{`json_contains_all(JSONField["A"], {array})`, map[string]*schemapb.TemplateValue{
"array": generateExpressionFieldData(schemapb.DataType_Array, []interface{}{
generateExpressionFieldData(schemapb.DataType_Int64, int64(1)),
generateExpressionFieldData(schemapb.DataType_String, "abc"),
generateExpressionFieldData(schemapb.DataType_Double, 2.2),
generateExpressionFieldData(schemapb.DataType_Bool, false),
}),
}},
{`json_contains_all(JSONField["A"], {array})`, map[string]*schemapb.TemplateValue{
"array": generateExpressionFieldData(schemapb.DataType_Array, []interface{}{
generateExpressionFieldData(schemapb.DataType_Array, []interface{}{
generateExpressionFieldData(schemapb.DataType_Int64, int64(1)),
generateExpressionFieldData(schemapb.DataType_Int64, int64(2)),
generateExpressionFieldData(schemapb.DataType_Int64, int64(3)),
}),
generateExpressionFieldData(schemapb.DataType_Array, []interface{}{
generateExpressionFieldData(schemapb.DataType_Int64, int64(4)),
generateExpressionFieldData(schemapb.DataType_Int64, int64(5)),
generateExpressionFieldData(schemapb.DataType_Int64, int64(6)),
}),
}),
}},
{`json_contains(ArrayField, {int})`, map[string]*schemapb.TemplateValue{
"int": generateExpressionFieldData(schemapb.DataType_Int64, int64(1)),
}},
{`json_contains_any(ArrayField, {list})`, map[string]*schemapb.TemplateValue{
"list": generateExpressionFieldData(schemapb.DataType_Array, []interface{}{
generateExpressionFieldData(schemapb.DataType_Int64, int64(1)),
generateExpressionFieldData(schemapb.DataType_Int64, int64(2)),
generateExpressionFieldData(schemapb.DataType_Int64, int64(3)),
generateExpressionFieldData(schemapb.DataType_Int64, int64(4)),
}),
}},
}
schemaH := newTestSchemaHelper(s.T())
for _, c := range testcases {
plan, err := CreateSearchPlan(schemaH, c.expr, "FloatVectorField", &planpb.QueryInfo{
Topk: 0,
MetricType: "",
SearchParams: "",
RoundDecimal: 0,
}, c.values)
s.NoError(err)
s.NotNil(plan)
s.NotNil(plan.GetVectorAnns())
s.NotNil(plan.GetVectorAnns().GetPredicates())
}
})
s.Run("failed case", func() {
testcases := []testcase{
{`json_contains(ArrayField[0], {str})`, map[string]*schemapb.TemplateValue{
"str": generateExpressionFieldData(schemapb.DataType_String, "abc"),
}},
{`json_contains_any(JSONField, {not_array})`, map[string]*schemapb.TemplateValue{
"not_array": generateExpressionFieldData(schemapb.DataType_Int64, int64(1)),
}},
{`json_contains_all(JSONField, {not_array})`, map[string]*schemapb.TemplateValue{
"not_array": generateExpressionFieldData(schemapb.DataType_Int64, int64(1)),
}},
{`json_contains_all(JSONField, {not_array})`, map[string]*schemapb.TemplateValue{
"array": generateExpressionFieldData(schemapb.DataType_Array, []interface{}{
generateExpressionFieldData(schemapb.DataType_Int64, int64(1)),
generateExpressionFieldData(schemapb.DataType_Int64, int64(2)),
generateExpressionFieldData(schemapb.DataType_Int64, int64(3)),
}),
}},
{`json_contains_all(ArrayField, {array})`, map[string]*schemapb.TemplateValue{
"array": generateExpressionFieldData(schemapb.DataType_Array, []interface{}{
generateExpressionFieldData(schemapb.DataType_Int64, int64(1)),
generateExpressionFieldData(schemapb.DataType_String, "abc"),
generateExpressionFieldData(schemapb.DataType_Double, 2.2),
generateExpressionFieldData(schemapb.DataType_Bool, false),
}),
}},
{`json_contains(ArrayField, {array})`, map[string]*schemapb.TemplateValue{
"array": generateExpressionFieldData(schemapb.DataType_Array, []interface{}{
generateExpressionFieldData(schemapb.DataType_Int64, int64(1)),
generateExpressionFieldData(schemapb.DataType_Int64, int64(2)),
generateExpressionFieldData(schemapb.DataType_Int64, int64(3)),
}),
}},
{`json_contains_any(ArrayField, {array})`, map[string]*schemapb.TemplateValue{
"array": generateExpressionFieldData(schemapb.DataType_Array, []interface{}{
generateExpressionFieldData(schemapb.DataType_Int64, int64(1)),
generateExpressionFieldData(schemapb.DataType_String, "abc"),
generateExpressionFieldData(schemapb.DataType_Double, 2.2),
generateExpressionFieldData(schemapb.DataType_Bool, false),
}),
}},
}
schemaH := newTestSchemaHelper(s.T())
for _, c := range testcases {
plan, err := CreateSearchPlan(schemaH, c.expr, "FloatVectorField", &planpb.QueryInfo{
Topk: 0,
MetricType: "",
SearchParams: "",
RoundDecimal: 0,
}, c.values)
s.Error(err)
s.Nil(plan)
}
})
}

14
internal/parser/planparserv2/generated/Plan.interp
View File

@ -5,6 +5,8 @@ null
'['
','
']'
'{'
'}'
'<'
'<='
'>'
@ -28,8 +30,6 @@ null
null
'~'
null
'in'
'not in'
null
null
null
@ -43,6 +43,8 @@ null
null
null
null
'$meta'
null
null
null
null
@ -54,6 +56,8 @@ null
null
null
null
LBRACE
RBRACE
LT
LE
GT
@ -78,8 +82,7 @@ OR
BNOT
NOT
IN
NIN
EmptyTerm
EmptyArray
JSONContains
JSONContainsAll
JSONContainsAny
@ -91,6 +94,7 @@ BooleanConstant
IntegerConstant
FloatingConstant
Identifier
Meta
StringLiteral
JSONIdentifier
Whitespace
@ -101,4 +105,4 @@ expr
atn:
[3, 24715, 42794, 33075, 47597, 16764, 15335, 30598, 22884, 3, 48, 131, 4, 2, 9, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 7, 2, 20, 10, 2, 12, 2, 14, 2, 23, 11, 2, 3, 2, 5, 2, 26, 10, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 5, 2, 59, 10, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 7, 2, 113, 10, 2, 12, 2, 14, 2, 116, 11, 2, 3, 2, 5, 2, 119, 10, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 7, 2, 126, 10, 2, 12, 2, 14, 2, 129, 11, 2, 3, 2, 2, 3, 2, 3, 2, 2, 15, 4, 2, 16, 17, 29, 30, 4, 2, 34, 34, 37, 37, 4, 2, 35, 35, 38, 38, 4, 2, 36, 36, 39, 39, 4, 2, 44, 44, 46, 46, 3, 2, 18, 20, 3, 2, 16, 17, 3, 2, 22, 23, 3, 2, 8, 9, 3, 2, 10, 11, 3, 2, 8, 11, 3, 2, 12, 13, 3, 2, 31, 32, 2, 162, 2, 58, 3, 2, 2, 2, 4, 5, 8, 2, 1, 2, 5, 59, 7, 42, 2, 2, 6, 59, 7, 43, 2, 2, 7, 59, 7, 41, 2, 2, 8, 59, 7, 45, 2, 2, 9, 59, 7, 44, 2, 2, 10, 59, 7, 46, 2, 2, 11, 12, 7, 3, 2, 2, 12, 13, 5, 2, 2, 2, 13, 14, 7, 4, 2, 2, 14, 59, 3, 2, 2, 2, 15, 16, 7, 5, 2, 2, 16, 21, 5, 2, 2, 2, 17, 18, 7, 6, 2, 2, 18, 20, 5, 2, 2, 2, 19, 17, 3, 2, 2, 2, 20, 23, 3, 2, 2, 2, 21, 19, 3, 2, 2, 2, 21, 22, 3, 2, 2, 2, 22, 25, 3, 2, 2, 2, 23, 21, 3, 2, 2, 2, 24, 26, 7, 6, 2, 2, 25, 24, 3, 2, 2, 2, 25, 26, 3, 2, 2, 2, 26, 27, 3, 2, 2, 2, 27, 28, 7, 7, 2, 2, 28, 59, 3, 2, 2, 2, 29, 30, 9, 2, 2, 2, 30, 59, 5, 2, 2, 22, 31, 32, 9, 3, 2, 2, 32, 33, 7, 3, 2, 2, 33, 34, 5, 2, 2, 2, 34, 35, 7, 6, 2, 2, 35, 36, 5, 2, 2, 2, 36, 37, 7, 4, 2, 2, 37, 59, 3, 2, 2, 2, 38, 39, 9, 4, 2, 2, 39, 40, 7, 3, 2, 2, 40, 41, 5, 2, 2, 2, 41, 42, 7, 6, 2, 2, 42, 43, 5, 2, 2, 2, 43, 44, 7, 4, 2, 2, 44, 59, 3, 2, 2, 2, 45, 46, 9, 5, 2, 2, 46, 47, 7, 3, 2, 2, 47, 48, 5, 2, 2, 2, 48, 49, 7, 6, 2, 2, 49, 50, 5, 2, 2, 2, 50, 51, 7, 4, 2, 2, 51, 59, 3, 2, 2, 2, 52, 53, 7, 40, 2, 2, 53, 54, 7, 3, 2, 2, 54, 55, 9, 6, 2, 2, 55, 59, 7, 4, 2, 2, 56, 57, 7, 15, 2, 2, 57, 59, 5, 2, 2, 3, 58, 4, 3, 2, 2, 2, 58, 6, 3, 2, 2, 2, 58, 7, 3, 2, 2, 2, 58, 8, 3, 2, 2, 2, 58, 9, 3, 2, 2, 2, 58, 10, 3, 2, 2, 2, 58, 11, 3, 2, 2, 2, 58, 15, 3, 2, 2, 2, 58, 29, 3, 2, 2, 2, 58, 31, 3, 2, 2, 2, 58, 38, 3, 2, 2, 2, 58, 45, 3, 2, 2, 2, 58, 52, 3, 2, 2, 2, 58, 56, 3, 2, 2, 2, 59, 127, 3, 2, 2, 2, 60, 61, 12, 23, 2, 2, 61, 62, 7, 21, 2, 2, 62, 126, 5, 2, 2, 24, 63, 64, 12, 21, 2, 2, 64, 65, 9, 7, 2, 2, 65, 126, 5, 2, 2, 22, 66, 67, 12, 20, 2, 2, 67, 68, 9, 8, 2, 2, 68, 126, 5, 2, 2, 21, 69, 70, 12, 19, 2, 2, 70, 71, 9, 9, 2, 2, 71, 126, 5, 2, 2, 20, 72, 73, 12, 12, 2, 2, 73, 74, 9, 10, 2, 2, 74, 75, 9, 6, 2, 2, 75, 76, 9, 10, 2, 2, 76, 126, 5, 2, 2, 13, 77, 78, 12, 11, 2, 2, 78, 79, 9, 11, 2, 2, 79, 80, 9, 6, 2, 2, 80, 81, 9, 11, 2, 2, 81, 126, 5, 2, 2, 12, 82, 83, 12, 10, 2, 2, 83, 84, 9, 12, 2, 2, 84, 126, 5, 2, 2, 11, 85, 86, 12, 9, 2, 2, 86, 87, 9, 13, 2, 2, 87, 126, 5, 2, 2, 10, 88, 89, 12, 8, 2, 2, 89, 90, 7, 24, 2, 2, 90, 126, 5, 2, 2, 9, 91, 92, 12, 7, 2, 2, 92, 93, 7, 26, 2, 2, 93, 126, 5, 2, 2, 8, 94, 95, 12, 6, 2, 2, 95, 96, 7, 25, 2, 2, 96, 126, 5, 2, 2, 7, 97, 98, 12, 5, 2, 2, 98, 99, 7, 27, 2, 2, 99, 126, 5, 2, 2, 6, 100, 101, 12, 4, 2, 2, 101, 102, 7, 28, 2, 2, 102, 126, 5, 2, 2, 5, 103, 104, 12, 24, 2, 2, 104, 105, 7, 14, 2, 2, 105, 126, 7, 45, 2, 2, 106, 107, 12, 18, 2, 2, 107, 108, 9, 14, 2, 2, 108, 109, 7, 5, 2, 2, 109, 114, 5, 2, 2, 2, 110, 111, 7, 6, 2, 2, 111, 113, 5, 2, 2, 2, 112, 110, 3, 2, 2, 2, 113, 116, 3, 2, 2, 2, 114, 112, 3, 2, 2, 2, 114, 115, 3, 2, 2, 2, 115, 118, 3, 2, 2, 2, 116, 114, 3, 2, 2, 2, 117, 119, 7, 6, 2, 2, 118, 117, 3, 2, 2, 2, 118, 119, 3, 2, 2, 2, 119, 120, 3, 2, 2, 2, 120, 121, 7, 7, 2, 2, 121, 126, 3, 2, 2, 2, 122, 123, 12, 17, 2, 2, 123, 124, 9, 14, 2, 2, 124, 126, 7, 33, 2, 2, 125, 60, 3, 2, 2, 2, 125, 63, 3, 2, 2, 2, 125, 66, 3, 2, 2, 2, 125, 69, 3, 2, 2, 2, 125, 72, 3, 2, 2, 2, 125, 77, 3, 2, 2, 2, 125, 82, 3, 2, 2, 2, 125, 85, 3, 2, 2, 2, 125, 88, 3, 2, 2, 2, 125, 91, 3, 2, 2, 2, 125, 94, 3, 2, 2, 2, 125, 97, 3, 2, 2, 2, 125, 100, 3, 2, 2, 2, 125, 103, 3, 2, 2, 2, 125, 106, 3, 2, 2, 2, 125, 122, 3, 2, 2, 2, 126, 129, 3, 2, 2, 2, 127, 125, 3, 2, 2, 2, 127, 128, 3, 2, 2, 2, 128, 3, 3, 2, 2, 2, 129, 127, 3, 2, 2, 2, 9, 21, 25, 58, 114, 118, 125, 127]
[3, 24715, 42794, 33075, 47597, 16764, 15335, 30598, 22884, 3, 50, 122, 4, 2, 9, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 7, 2, 23, 10, 2, 12, 2, 14, 2, 26, 11, 2, 3, 2, 5, 2, 29, 10, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 5, 2, 63, 10, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 5, 2, 79, 10, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 7, 2, 117, 10, 2, 12, 2, 14, 2, 120, 11, 2, 3, 2, 2, 3, 2, 3, 2, 2, 15, 3, 2, 45, 46, 4, 2, 18, 19, 31, 32, 4, 2, 35, 35, 38, 38, 4, 2, 36, 36, 39, 39, 4, 2, 37, 37, 40, 40, 4, 2, 45, 45, 48, 48, 3, 2, 20, 22, 3, 2, 18, 19, 3, 2, 24, 25, 3, 2, 10, 11, 3, 2, 12, 13, 3, 2, 10, 13, 3, 2, 14, 15, 2, 153, 2, 62, 3, 2, 2, 2, 4, 5, 8, 2, 1, 2, 5, 63, 7, 43, 2, 2, 6, 63, 7, 44, 2, 2, 7, 63, 7, 42, 2, 2, 8, 63, 7, 47, 2, 2, 9, 63, 9, 2, 2, 2, 10, 63, 7, 48, 2, 2, 11, 12, 7, 8, 2, 2, 12, 13, 7, 45, 2, 2, 13, 63, 7, 9, 2, 2, 14, 15, 7, 3, 2, 2, 15, 16, 5, 2, 2, 2, 16, 17, 7, 4, 2, 2, 17, 63, 3, 2, 2, 2, 18, 19, 7, 5, 2, 2, 19, 24, 5, 2, 2, 2, 20, 21, 7, 6, 2, 2, 21, 23, 5, 2, 2, 2, 22, 20, 3, 2, 2, 2, 23, 26, 3, 2, 2, 2, 24, 22, 3, 2, 2, 2, 24, 25, 3, 2, 2, 2, 25, 28, 3, 2, 2, 2, 26, 24, 3, 2, 2, 2, 27, 29, 7, 6, 2, 2, 28, 27, 3, 2, 2, 2, 28, 29, 3, 2, 2, 2, 29, 30, 3, 2, 2, 2, 30, 31, 7, 7, 2, 2, 31, 63, 3, 2, 2, 2, 32, 63, 7, 34, 2, 2, 33, 34, 9, 3, 2, 2, 34, 63, 5, 2, 2, 21, 35, 36, 9, 4, 2, 2, 36, 37, 7, 3, 2, 2, 37, 38, 5, 2, 2, 2, 38, 39, 7, 6, 2, 2, 39, 40, 5, 2, 2, 2, 40, 41, 7, 4, 2, 2, 41, 63, 3, 2, 2, 2, 42, 43, 9, 5, 2, 2, 43, 44, 7, 3, 2, 2, 44, 45, 5, 2, 2, 2, 45, 46, 7, 6, 2, 2, 46, 47, 5, 2, 2, 2, 47, 48, 7, 4, 2, 2, 48, 63, 3, 2, 2, 2, 49, 50, 9, 6, 2, 2, 50, 51, 7, 3, 2, 2, 51, 52, 5, 2, 2, 2, 52, 53, 7, 6, 2, 2, 53, 54, 5, 2, 2, 2, 54, 55, 7, 4, 2, 2, 55, 63, 3, 2, 2, 2, 56, 57, 7, 41, 2, 2, 57, 58, 7, 3, 2, 2, 58, 59, 9, 7, 2, 2, 59, 63, 7, 4, 2, 2, 60, 61, 7, 17, 2, 2, 61, 63, 5, 2, 2, 3, 62, 4, 3, 2, 2, 2, 62, 6, 3, 2, 2, 2, 62, 7, 3, 2, 2, 2, 62, 8, 3, 2, 2, 2, 62, 9, 3, 2, 2, 2, 62, 10, 3, 2, 2, 2, 62, 11, 3, 2, 2, 2, 62, 14, 3, 2, 2, 2, 62, 18, 3, 2, 2, 2, 62, 32, 3, 2, 2, 2, 62, 33, 3, 2, 2, 2, 62, 35, 3, 2, 2, 2, 62, 42, 3, 2, 2, 2, 62, 49, 3, 2, 2, 2, 62, 56, 3, 2, 2, 2, 62, 60, 3, 2, 2, 2, 63, 118, 3, 2, 2, 2, 64, 65, 12, 22, 2, 2, 65, 66, 7, 23, 2, 2, 66, 117, 5, 2, 2, 23, 67, 68, 12, 20, 2, 2, 68, 69, 9, 8, 2, 2, 69, 117, 5, 2, 2, 21, 70, 71, 12, 19, 2, 2, 71, 72, 9, 9, 2, 2, 72, 117, 5, 2, 2, 20, 73, 74, 12, 18, 2, 2, 74, 75, 9, 10, 2, 2, 75, 117, 5, 2, 2, 19, 76, 78, 12, 17, 2, 2, 77, 79, 7, 32, 2, 2, 78, 77, 3, 2, 2, 2, 78, 79, 3, 2, 2, 2, 79, 80, 3, 2, 2, 2, 80, 81, 7, 33, 2, 2, 81, 117, 5, 2, 2, 18, 82, 83, 12, 12, 2, 2, 83, 84, 9, 11, 2, 2, 84, 85, 9, 7, 2, 2, 85, 86, 9, 11, 2, 2, 86, 117, 5, 2, 2, 13, 87, 88, 12, 11, 2, 2, 88, 89, 9, 12, 2, 2, 89, 90, 9, 7, 2, 2, 90, 91, 9, 12, 2, 2, 91, 117, 5, 2, 2, 12, 92, 93, 12, 10, 2, 2, 93, 94, 9, 13, 2, 2, 94, 117, 5, 2, 2, 11, 95, 96, 12, 9, 2, 2, 96, 97, 9, 14, 2, 2, 97, 117, 5, 2, 2, 10, 98, 99, 12, 8, 2, 2, 99, 100, 7, 26, 2, 2, 100, 117, 5, 2, 2, 9, 101, 102, 12, 7, 2, 2, 102, 103, 7, 28, 2, 2, 103, 117, 5, 2, 2, 8, 104, 105, 12, 6, 2, 2, 105, 106, 7, 27, 2, 2, 106, 117, 5, 2, 2, 7, 107, 108, 12, 5, 2, 2, 108, 109, 7, 29, 2, 2, 109, 117, 5, 2, 2, 6, 110, 111, 12, 4, 2, 2, 111, 112, 7, 30, 2, 2, 112, 117, 5, 2, 2, 5, 113, 114, 12, 23, 2, 2, 114, 115, 7, 16, 2, 2, 115, 117, 7, 47, 2, 2, 116, 64, 3, 2, 2, 2, 116, 67, 3, 2, 2, 2, 116, 70, 3, 2, 2, 2, 116, 73, 3, 2, 2, 2, 116, 76, 3, 2, 2, 2, 116, 82, 3, 2, 2, 2, 116, 87, 3, 2, 2, 2, 116, 92, 3, 2, 2, 2, 116, 95, 3, 2, 2, 2, 116, 98, 3, 2, 2, 2, 116, 101, 3, 2, 2, 2, 116, 104, 3, 2, 2, 2, 116, 107, 3, 2, 2, 2, 116, 110, 3, 2, 2, 2, 116, 113, 3, 2, 2, 2, 117, 120, 3, 2, 2, 2, 118, 116, 3, 2, 2, 2, 118, 119, 3, 2, 2, 2, 119, 3, 3, 2, 2, 2, 120, 118, 3, 2, 2, 2, 8, 24, 28, 62, 78, 116, 118]

125
internal/parser/planparserv2/generated/Plan.tokens
View File

@ -3,69 +3,72 @@ T__1=2
T__2=3
T__3=4
T__4=5
LT=6
LE=7
GT=8
GE=9
EQ=10
NE=11
LIKE=12
EXISTS=13
ADD=14
SUB=15
MUL=16
DIV=17
MOD=18
POW=19
SHL=20
SHR=21
BAND=22
BOR=23
BXOR=24
AND=25
OR=26
BNOT=27
NOT=28
IN=29
NIN=30
EmptyTerm=31
JSONContains=32
JSONContainsAll=33
JSONContainsAny=34
ArrayContains=35
ArrayContainsAll=36
ArrayContainsAny=37
ArrayLength=38
BooleanConstant=39
IntegerConstant=40
FloatingConstant=41
Identifier=42
StringLiteral=43
JSONIdentifier=44
Whitespace=45
Newline=46
LBRACE=6
RBRACE=7
LT=8
LE=9
GT=10
GE=11
EQ=12
NE=13
LIKE=14
EXISTS=15
ADD=16
SUB=17
MUL=18
DIV=19
MOD=20
POW=21
SHL=22
SHR=23
BAND=24
BOR=25
BXOR=26
AND=27
OR=28
BNOT=29
NOT=30
IN=31
EmptyArray=32
JSONContains=33
JSONContainsAll=34
JSONContainsAny=35
ArrayContains=36
ArrayContainsAll=37
ArrayContainsAny=38
ArrayLength=39
BooleanConstant=40
IntegerConstant=41
FloatingConstant=42
Identifier=43
Meta=44
StringLiteral=45
JSONIdentifier=46
Whitespace=47
Newline=48
'('=1
')'=2
'['=3
','=4
']'=5
'<'=6
'<='=7
'>'=8
'>='=9
'=='=10
'!='=11
'+'=14
'-'=15
'*'=16
'/'=17
'%'=18
'**'=19
'<<'=20
'>>'=21
'&'=22
'|'=23
'^'=24
'~'=27
'in'=29
'not in'=30
'{'=6
'}'=7
'<'=8
'<='=9
'>'=10
'>='=11
'=='=12
'!='=13
'+'=16
'-'=17
'*'=18
'/'=19
'%'=20
'**'=21
'<<'=22
'>>'=23
'&'=24
'|'=25
'^'=26
'~'=29
'$meta'=44

20
internal/parser/planparserv2/generated/PlanLexer.interp
View File

File diff suppressed because one or more lines are too long

125
internal/parser/planparserv2/generated/PlanLexer.tokens
View File

@ -3,69 +3,72 @@ T__1=2
T__2=3
T__3=4
T__4=5
LT=6
LE=7
GT=8
GE=9
EQ=10
NE=11
LIKE=12
EXISTS=13
ADD=14
SUB=15
MUL=16
DIV=17
MOD=18
POW=19
SHL=20
SHR=21
BAND=22
BOR=23
BXOR=24
AND=25
OR=26
BNOT=27
NOT=28
IN=29
NIN=30
EmptyTerm=31
JSONContains=32
JSONContainsAll=33
JSONContainsAny=34
ArrayContains=35
ArrayContainsAll=36
ArrayContainsAny=37
ArrayLength=38
BooleanConstant=39
IntegerConstant=40
FloatingConstant=41
Identifier=42
StringLiteral=43
JSONIdentifier=44
Whitespace=45
Newline=46
LBRACE=6
RBRACE=7
LT=8
LE=9
GT=10
GE=11
EQ=12
NE=13
LIKE=14
EXISTS=15
ADD=16
SUB=17
MUL=18
DIV=19
MOD=20
POW=21
SHL=22
SHR=23
BAND=24
BOR=25
BXOR=26
AND=27
OR=28
BNOT=29
NOT=30
IN=31
EmptyArray=32
JSONContains=33
JSONContainsAll=34
JSONContainsAny=35
ArrayContains=36
ArrayContainsAll=37
ArrayContainsAny=38
ArrayLength=39
BooleanConstant=40
IntegerConstant=41
FloatingConstant=42
Identifier=43
Meta=44
StringLiteral=45
JSONIdentifier=46
Whitespace=47
Newline=48
'('=1
')'=2
'['=3
','=4
']'=5
'<'=6
'<='=7
'>'=8
'>='=9
'=='=10
'!='=11
'+'=14
'-'=15
'*'=16
'/'=17
'%'=18
'**'=19
'<<'=20
'>>'=21
'&'=22
'|'=23
'^'=24
'~'=27
'in'=29
'not in'=30
'{'=6
'}'=7
'<'=8
'<='=9
'>'=10
'>='=11
'=='=12
'!='=13
'+'=16
'-'=17
'*'=18
'/'=19
'%'=20
'**'=21
'<<'=22
'>>'=23
'&'=24
'|'=25
'^'=26
'~'=29
'$meta'=44

12
internal/parser/planparserv2/generated/plan_base_visitor.go
View File

@ -47,6 +47,10 @@ func (v *BasePlanVisitor) VisitLogicalAnd(ctx *LogicalAndContext) interface{} {
return v.VisitChildren(ctx)
}
func (v *BasePlanVisitor) VisitTemplateVariable(ctx *TemplateVariableContext) interface{} {
return v.VisitChildren(ctx)
}
func (v *BasePlanVisitor) VisitEquality(ctx *EqualityContext) interface{} {
return v.VisitChildren(ctx)
}
@ -67,6 +71,10 @@ func (v *BasePlanVisitor) VisitBitOr(ctx *BitOrContext) interface{} {
return v.VisitChildren(ctx)
}
func (v *BasePlanVisitor) VisitEmptyArray(ctx *EmptyArrayContext) interface{} {
return v.VisitChildren(ctx)
}
func (v *BasePlanVisitor) VisitAddSub(ctx *AddSubContext) interface{} {
return v.VisitChildren(ctx)
}
@ -119,10 +127,6 @@ func (v *BasePlanVisitor) VisitBitAnd(ctx *BitAndContext) interface{} {
return v.VisitChildren(ctx)
}
func (v *BasePlanVisitor) VisitEmptyTerm(ctx *EmptyTermContext) interface{} {
return v.VisitChildren(ctx)
}
func (v *BasePlanVisitor) VisitPower(ctx *PowerContext) interface{} {
return v.VisitChildren(ctx)
}

780
internal/parser/planparserv2/generated/plan_lexer.go
View File

@ -14,7 +14,7 @@ var _ = fmt.Printf
var _ = unicode.IsLetter
var serializedLexerAtn = []uint16{
3, 24715, 42794, 33075, 47597, 16764, 15335, 30598, 22884, 2, 48, 754,
3, 24715, 42794, 33075, 47597, 16764, 15335, 30598, 22884, 2, 50, 760,
8, 1, 4, 2, 9, 2, 4, 3, 9, 3, 4, 4, 9, 4, 4, 5, 9, 5, 4, 6, 9, 6, 4, 7,
9, 7, 4, 8, 9, 8, 4, 9, 9, 9, 4, 10, 9, 10, 4, 11, 9, 11, 4, 12, 9, 12,
4, 13, 9, 13, 4, 14, 9, 14, 4, 15, 9, 15, 4, 16, 9, 16, 4, 17, 9, 17, 4,
@ -28,335 +28,338 @@ var serializedLexerAtn = []uint16{
4, 55, 9, 55, 4, 56, 9, 56, 4, 57, 9, 57, 4, 58, 9, 58, 4, 59, 9, 59, 4,
60, 9, 60, 4, 61, 9, 61, 4, 62, 9, 62, 4, 63, 9, 63, 4, 64, 9, 64, 4, 65,
9, 65, 4, 66, 9, 66, 4, 67, 9, 67, 4, 68, 9, 68, 4, 69, 9, 69, 4, 70, 9,
70, 4, 71, 9, 71, 4, 72, 9, 72, 3, 2, 3, 2, 3, 3, 3, 3, 3, 4, 3, 4, 3,
5, 3, 5, 3, 6, 3, 6, 3, 7, 3, 7, 3, 8, 3, 8, 3, 8, 3, 9, 3, 9, 3, 10, 3,
10, 3, 10, 3, 11, 3, 11, 3, 11, 3, 12, 3, 12, 3, 12, 3, 13, 3, 13, 3, 13,
3, 13, 3, 13, 3, 13, 3, 13, 3, 13, 5, 13, 180, 10, 13, 3, 14, 3, 14, 3,
14, 3, 14, 3, 14, 3, 14, 3, 14, 3, 14, 3, 14, 3, 14, 3, 14, 3, 14, 5, 14,
194, 10, 14, 3, 15, 3, 15, 3, 16, 3, 16, 3, 17, 3, 17, 3, 18, 3, 18, 3,
19, 3, 19, 3, 20, 3, 20, 3, 20, 3, 21, 3, 21, 3, 21, 3, 22, 3, 22, 3, 22,
3, 23, 3, 23, 3, 24, 3, 24, 3, 25, 3, 25, 3, 26, 3, 26, 3, 26, 3, 26, 3,
26, 5, 26, 226, 10, 26, 3, 27, 3, 27, 3, 27, 3, 27, 5, 27, 232, 10, 27,
3, 28, 3, 28, 3, 29, 3, 29, 3, 29, 3, 29, 5, 29, 240, 10, 29, 3, 30, 3,
30, 3, 30, 3, 31, 3, 31, 3, 31, 3, 31, 3, 31, 3, 31, 3, 31, 3, 32, 3, 32,
3, 32, 7, 32, 255, 10, 32, 12, 32, 14, 32, 258, 11, 32, 3, 32, 3, 32, 3,
33, 3, 33, 3, 33, 3, 33, 3, 33, 3, 33, 3, 33, 3, 33, 3, 33, 3, 33, 3, 33,
3, 33, 3, 33, 3, 33, 3, 33, 3, 33, 3, 33, 3, 33, 3, 33, 3, 33, 3, 33, 3,
33, 3, 33, 3, 33, 3, 33, 3, 33, 5, 33, 288, 10, 33, 3, 34, 3, 34, 3, 34,
70, 4, 71, 9, 71, 4, 72, 9, 72, 4, 73, 9, 73, 4, 74, 9, 74, 3, 2, 3, 2,
3, 3, 3, 3, 3, 4, 3, 4, 3, 5, 3, 5, 3, 6, 3, 6, 3, 7, 3, 7, 3, 8, 3, 8,
3, 9, 3, 9, 3, 10, 3, 10, 3, 10, 3, 11, 3, 11, 3, 12, 3, 12, 3, 12, 3,
13, 3, 13, 3, 13, 3, 14, 3, 14, 3, 14, 3, 15, 3, 15, 3, 15, 3, 15, 3, 15,
3, 15, 3, 15, 3, 15, 5, 15, 188, 10, 15, 3, 16, 3, 16, 3, 16, 3, 16, 3,
16, 3, 16, 3, 16, 3, 16, 3, 16, 3, 16, 3, 16, 3, 16, 5, 16, 202, 10, 16,
3, 17, 3, 17, 3, 18, 3, 18, 3, 19, 3, 19, 3, 20, 3, 20, 3, 21, 3, 21, 3,
22, 3, 22, 3, 22, 3, 23, 3, 23, 3, 23, 3, 24, 3, 24, 3, 24, 3, 25, 3, 25,
3, 26, 3, 26, 3, 27, 3, 27, 3, 28, 3, 28, 3, 28, 3, 28, 3, 28, 5, 28, 234,
10, 28, 3, 29, 3, 29, 3, 29, 3, 29, 5, 29, 240, 10, 29, 3, 30, 3, 30, 3,
31, 3, 31, 3, 31, 3, 31, 5, 31, 248, 10, 31, 3, 32, 3, 32, 3, 32, 3, 32,
5, 32, 254, 10, 32, 3, 33, 3, 33, 3, 33, 7, 33, 259, 10, 33, 12, 33, 14,
33, 262, 11, 33, 3, 33, 3, 33, 3, 34, 3, 34, 3, 34, 3, 34, 3, 34, 3, 34,
3, 34, 3, 34, 3, 34, 3, 34, 3, 34, 3, 34, 3, 34, 3, 34, 3, 34, 3, 34, 3,
34, 3, 34, 3, 34, 3, 34, 3, 34, 3, 34, 3, 34, 3, 34, 3, 34, 3, 34, 3, 34,
3, 34, 3, 34, 3, 34, 3, 34, 3, 34, 3, 34, 3, 34, 3, 34, 3, 34, 3, 34, 5,
34, 324, 10, 34, 3, 35, 3, 35, 3, 35, 3, 35, 3, 35, 3, 35, 3, 35, 3, 35,
3, 35, 3, 35, 3, 35, 3, 35, 3, 35, 3, 35, 3, 35, 3, 35, 3, 35, 3, 35, 3,
34, 3, 34, 3, 34, 3, 34, 3, 34, 3, 34, 3, 34, 3, 34, 3, 34, 3, 34, 5, 34,
292, 10, 34, 3, 35, 3, 35, 3, 35, 3, 35, 3, 35, 3, 35, 3, 35, 3, 35, 3,
35, 3, 35, 3, 35, 3, 35, 3, 35, 3, 35, 3, 35, 3, 35, 3, 35, 3, 35, 3, 35,
3, 35, 3, 35, 3, 35, 3, 35, 3, 35, 5, 35, 360, 10, 35, 3, 36, 3, 36, 3,
36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36,
3, 35, 3, 35, 3, 35, 3, 35, 3, 35, 3, 35, 3, 35, 3, 35, 3, 35, 3, 35, 3,
35, 3, 35, 3, 35, 3, 35, 3, 35, 5, 35, 328, 10, 35, 3, 36, 3, 36, 3, 36,
3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3,
36, 3, 36, 3, 36, 3, 36, 3, 36, 5, 36, 390, 10, 36, 3, 37, 3, 37, 3, 37,
36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36,
3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 5,
36, 364, 10, 36, 3, 37, 3, 37, 3, 37, 3, 37, 3, 37, 3, 37, 3, 37, 3, 37,
3, 37, 3, 37, 3, 37, 3, 37, 3, 37, 3, 37, 3, 37, 3, 37, 3, 37, 3, 37, 3,
37, 3, 37, 3, 37, 3, 37, 3, 37, 3, 37, 3, 37, 3, 37, 3, 37, 3, 37, 3, 37,
3, 37, 3, 37, 3, 37, 3, 37, 3, 37, 3, 37, 3, 37, 3, 37, 3, 37, 3, 37, 3,
37, 3, 37, 5, 37, 428, 10, 37, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38,
3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 3,
37, 3, 37, 3, 37, 3, 37, 3, 37, 3, 37, 3, 37, 3, 37, 3, 37, 3, 37, 5, 37,
394, 10, 37, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 3,
38, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38,
3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 5, 38, 466,
10, 38, 3, 39, 3, 39, 3, 39, 3, 39, 3, 39, 3, 39, 3, 39, 3, 39, 3, 39,
3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 3,
38, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 5, 38, 432, 10, 38, 3, 39,
3, 39, 3, 39, 3, 39, 3, 39, 3, 39, 3, 39, 3, 39, 3, 39, 3, 39, 3, 39, 3,
39, 3, 39, 3, 39, 3, 39, 3, 39, 5, 39, 492, 10, 39, 3, 40, 3, 40, 3, 40,
39, 3, 39, 3, 39, 3, 39, 3, 39, 3, 39, 3, 39, 3, 39, 3, 39, 3, 39, 3, 39,
3, 39, 3, 39, 3, 39, 3, 39, 3, 39, 3, 39, 3, 39, 3, 39, 3, 39, 3, 39, 3,
39, 3, 39, 3, 39, 3, 39, 5, 39, 470, 10, 39, 3, 40, 3, 40, 3, 40, 3, 40,
3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3,
40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40,
3, 40, 3, 40, 3, 40, 5, 40, 521, 10, 40, 3, 41, 3, 41, 3, 41, 3, 41, 5,
41, 527, 10, 41, 3, 42, 3, 42, 5, 42, 531, 10, 42, 3, 43, 3, 43, 3, 43,
7, 43, 536, 10, 43, 12, 43, 14, 43, 539, 11, 43, 3, 43, 3, 43, 3, 43, 3,
43, 3, 43, 5, 43, 546, 10, 43, 3, 44, 5, 44, 549, 10, 44, 3, 44, 3, 44,
5, 44, 553, 10, 44, 3, 44, 3, 44, 3, 44, 5, 44, 558, 10, 44, 3, 44, 5,
44, 561, 10, 44, 3, 45, 3, 45, 3, 45, 3, 45, 5, 45, 567, 10, 45, 3, 45,
3, 45, 6, 45, 571, 10, 45, 13, 45, 14, 45, 572, 3, 46, 3, 46, 3, 46, 5,
46, 578, 10, 46, 3, 47, 6, 47, 581, 10, 47, 13, 47, 14, 47, 582, 3, 48,
6, 48, 586, 10, 48, 13, 48, 14, 48, 587, 3, 49, 3, 49, 3, 49, 3, 49, 3,
49, 3, 49, 3, 49, 5, 49, 597, 10, 49, 3, 50, 3, 50, 3, 50, 3, 50, 3, 50,
3, 50, 3, 50, 5, 50, 606, 10, 50, 3, 51, 3, 51, 3, 52, 3, 52, 3, 53, 3,
53, 3, 53, 6, 53, 615, 10, 53, 13, 53, 14, 53, 616, 3, 54, 3, 54, 7, 54,
621, 10, 54, 12, 54, 14, 54, 624, 11, 54, 3, 54, 5, 54, 627, 10, 54, 3,
55, 3, 55, 7, 55, 631, 10, 55, 12, 55, 14, 55, 634, 11, 55, 3, 56, 3, 56,
3, 56, 3, 56, 3, 57, 3, 57, 3, 58, 3, 58, 3, 59, 3, 59, 3, 60, 3, 60, 3,
60, 3, 60, 3, 60, 3, 61, 3, 61, 3, 61, 3, 61, 3, 61, 3, 61, 3, 61, 3, 61,
3, 61, 3, 61, 5, 61, 661, 10, 61, 3, 62, 3, 62, 5, 62, 665, 10, 62, 3,
62, 3, 62, 3, 62, 5, 62, 670, 10, 62, 3, 63, 3, 63, 3, 63, 3, 63, 5, 63,
676, 10, 63, 3, 63, 3, 63, 3, 64, 5, 64, 681, 10, 64, 3, 64, 3, 64, 3,
64, 3, 64, 3, 64, 5, 64, 688, 10, 64, 3, 65, 3, 65, 5, 65, 692, 10, 65,
3, 65, 3, 65, 3, 66, 6, 66, 697, 10, 66, 13, 66, 14, 66, 698, 3, 67, 5,
67, 702, 10, 67, 3, 67, 3, 67, 3, 67, 3, 67, 3, 67, 5, 67, 709, 10, 67,
3, 68, 6, 68, 712, 10, 68, 13, 68, 14, 68, 713, 3, 69, 3, 69, 5, 69, 718,
10, 69, 3, 69, 3, 69, 3, 70, 3, 70, 3, 70, 3, 70, 3, 70, 5, 70, 727, 10,
70, 3, 70, 5, 70, 730, 10, 70, 3, 70, 3, 70, 3, 70, 3, 70, 3, 70, 5, 70,
737, 10, 70, 3, 71, 6, 71, 740, 10, 71, 13, 71, 14, 71, 741, 3, 71, 3,
71, 3, 72, 3, 72, 5, 72, 748, 10, 72, 3, 72, 5, 72, 751, 10, 72, 3, 72,
3, 72, 2, 2, 73, 3, 3, 5, 4, 7, 5, 9, 6, 11, 7, 13, 8, 15, 9, 17, 10, 19,
11, 21, 12, 23, 13, 25, 14, 27, 15, 29, 16, 31, 17, 33, 18, 35, 19, 37,
20, 39, 21, 41, 22, 43, 23, 45, 24, 47, 25, 49, 26, 51, 27, 53, 28, 55,
29, 57, 30, 59, 31, 61, 32, 63, 33, 65, 34, 67, 35, 69, 36, 71, 37, 73,
38, 75, 39, 77, 40, 79, 41, 81, 42, 83, 43, 85, 44, 87, 45, 89, 46, 91,
2, 93, 2, 95, 2, 97, 2, 99, 2, 101, 2, 103, 2, 105, 2, 107, 2, 109, 2,
111, 2, 113, 2, 115, 2, 117, 2, 119, 2, 121, 2, 123, 2, 125, 2, 127, 2,
129, 2, 131, 2, 133, 2, 135, 2, 137, 2, 139, 2, 141, 47, 143, 48, 3, 2,
18, 5, 2, 78, 78, 87, 87, 119, 119, 6, 2, 12, 12, 15, 15, 36, 36, 94, 94,
6, 2, 12, 12, 15, 15, 41, 41, 94, 94, 5, 2, 67, 92, 97, 97, 99, 124, 3,
2, 50, 59, 4, 2, 68, 68, 100, 100, 3, 2, 50, 51, 4, 2, 90, 90, 122, 122,
3, 2, 51, 59, 3, 2, 50, 57, 5, 2, 50, 59, 67, 72, 99, 104, 4, 2, 71, 71,
103, 103, 4, 2, 45, 45, 47, 47, 4, 2, 82, 82, 114, 114, 12, 2, 36, 36,
41, 41, 65, 65, 94, 94, 99, 100, 104, 104, 112, 112, 116, 116, 118, 118,
120, 120, 4, 2, 11, 11, 34, 34, 2, 793, 2, 3, 3, 2, 2, 2, 2, 5, 3, 2, 2,
2, 2, 7, 3, 2, 2, 2, 2, 9, 3, 2, 2, 2, 2, 11, 3, 2, 2, 2, 2, 13, 3, 2,
2, 2, 2, 15, 3, 2, 2, 2, 2, 17, 3, 2, 2, 2, 2, 19, 3, 2, 2, 2, 2, 21, 3,
2, 2, 2, 2, 23, 3, 2, 2, 2, 2, 25, 3, 2, 2, 2, 2, 27, 3, 2, 2, 2, 2, 29,
3, 2, 2, 2, 2, 31, 3, 2, 2, 2, 2, 33, 3, 2, 2, 2, 2, 35, 3, 2, 2, 2, 2,
37, 3, 2, 2, 2, 2, 39, 3, 2, 2, 2, 2, 41, 3, 2, 2, 2, 2, 43, 3, 2, 2, 2,
2, 45, 3, 2, 2, 2, 2, 47, 3, 2, 2, 2, 2, 49, 3, 2, 2, 2, 2, 51, 3, 2, 2,
2, 2, 53, 3, 2, 2, 2, 2, 55, 3, 2, 2, 2, 2, 57, 3, 2, 2, 2, 2, 59, 3, 2,
2, 2, 2, 61, 3, 2, 2, 2, 2, 63, 3, 2, 2, 2, 2, 65, 3, 2, 2, 2, 2, 67, 3,
2, 2, 2, 2, 69, 3, 2, 2, 2, 2, 71, 3, 2, 2, 2, 2, 73, 3, 2, 2, 2, 2, 75,
3, 2, 2, 2, 2, 77, 3, 2, 2, 2, 2, 79, 3, 2, 2, 2, 2, 81, 3, 2, 2, 2, 2,
83, 3, 2, 2, 2, 2, 85, 3, 2, 2, 2, 2, 87, 3, 2, 2, 2, 2, 89, 3, 2, 2, 2,
2, 141, 3, 2, 2, 2, 2, 143, 3, 2, 2, 2, 3, 145, 3, 2, 2, 2, 5, 147, 3,
2, 2, 2, 7, 149, 3, 2, 2, 2, 9, 151, 3, 2, 2, 2, 11, 153, 3, 2, 2, 2, 13,
155, 3, 2, 2, 2, 15, 157, 3, 2, 2, 2, 17, 160, 3, 2, 2, 2, 19, 162, 3,
2, 2, 2, 21, 165, 3, 2, 2, 2, 23, 168, 3, 2, 2, 2, 25, 179, 3, 2, 2, 2,
27, 193, 3, 2, 2, 2, 29, 195, 3, 2, 2, 2, 31, 197, 3, 2, 2, 2, 33, 199,
3, 2, 2, 2, 35, 201, 3, 2, 2, 2, 37, 203, 3, 2, 2, 2, 39, 205, 3, 2, 2,
2, 41, 208, 3, 2, 2, 2, 43, 211, 3, 2, 2, 2, 45, 214, 3, 2, 2, 2, 47, 216,
3, 2, 2, 2, 49, 218, 3, 2, 2, 2, 51, 225, 3, 2, 2, 2, 53, 231, 3, 2, 2,
2, 55, 233, 3, 2, 2, 2, 57, 239, 3, 2, 2, 2, 59, 241, 3, 2, 2, 2, 61, 244,
3, 2, 2, 2, 63, 251, 3, 2, 2, 2, 65, 287, 3, 2, 2, 2, 67, 323, 3, 2, 2,
2, 69, 359, 3, 2, 2, 2, 71, 389, 3, 2, 2, 2, 73, 427, 3, 2, 2, 2, 75, 465,
3, 2, 2, 2, 77, 491, 3, 2, 2, 2, 79, 520, 3, 2, 2, 2, 81, 526, 3, 2, 2,
2, 83, 530, 3, 2, 2, 2, 85, 545, 3, 2, 2, 2, 87, 548, 3, 2, 2, 2, 89, 562,
3, 2, 2, 2, 91, 577, 3, 2, 2, 2, 93, 580, 3, 2, 2, 2, 95, 585, 3, 2, 2,
2, 97, 596, 3, 2, 2, 2, 99, 605, 3, 2, 2, 2, 101, 607, 3, 2, 2, 2, 103,
609, 3, 2, 2, 2, 105, 611, 3, 2, 2, 2, 107, 626, 3, 2, 2, 2, 109, 628,
3, 2, 2, 2, 111, 635, 3, 2, 2, 2, 113, 639, 3, 2, 2, 2, 115, 641, 3, 2,
2, 2, 117, 643, 3, 2, 2, 2, 119, 645, 3, 2, 2, 2, 121, 660, 3, 2, 2, 2,
123, 669, 3, 2, 2, 2, 125, 671, 3, 2, 2, 2, 127, 687, 3, 2, 2, 2, 129,
689, 3, 2, 2, 2, 131, 696, 3, 2, 2, 2, 133, 708, 3, 2, 2, 2, 135, 711,
3, 2, 2, 2, 137, 715, 3, 2, 2, 2, 139, 736, 3, 2, 2, 2, 141, 739, 3, 2,
2, 2, 143, 750, 3, 2, 2, 2, 145, 146, 7, 42, 2, 2, 146, 4, 3, 2, 2, 2,
147, 148, 7, 43, 2, 2, 148, 6, 3, 2, 2, 2, 149, 150, 7, 93, 2, 2, 150,
8, 3, 2, 2, 2, 151, 152, 7, 46, 2, 2, 152, 10, 3, 2, 2, 2, 153, 154, 7,
95, 2, 2, 154, 12, 3, 2, 2, 2, 155, 156, 7, 62, 2, 2, 156, 14, 3, 2, 2,
2, 157, 158, 7, 62, 2, 2, 158, 159, 7, 63, 2, 2, 159, 16, 3, 2, 2, 2, 160,
161, 7, 64, 2, 2, 161, 18, 3, 2, 2, 2, 162, 163, 7, 64, 2, 2, 163, 164,
7, 63, 2, 2, 164, 20, 3, 2, 2, 2, 165, 166, 7, 63, 2, 2, 166, 167, 7, 63,
2, 2, 167, 22, 3, 2, 2, 2, 168, 169, 7, 35, 2, 2, 169, 170, 7, 63, 2, 2,
170, 24, 3, 2, 2, 2, 171, 172, 7, 110, 2, 2, 172, 173, 7, 107, 2, 2, 173,
174, 7, 109, 2, 2, 174, 180, 7, 103, 2, 2, 175, 176, 7, 78, 2, 2, 176,
177, 7, 75, 2, 2, 177, 178, 7, 77, 2, 2, 178, 180, 7, 71, 2, 2, 179, 171,
3, 2, 2, 2, 179, 175, 3, 2, 2, 2, 180, 26, 3, 2, 2, 2, 181, 182, 7, 103,
2, 2, 182, 183, 7, 122, 2, 2, 183, 184, 7, 107, 2, 2, 184, 185, 7, 117,
2, 2, 185, 186, 7, 118, 2, 2, 186, 194, 7, 117, 2, 2, 187, 188, 7, 71,
2, 2, 188, 189, 7, 90, 2, 2, 189, 190, 7, 75, 2, 2, 190, 191, 7, 85, 2,
2, 191, 192, 7, 86, 2, 2, 192, 194, 7, 85, 2, 2, 193, 181, 3, 2, 2, 2,
193, 187, 3, 2, 2, 2, 194, 28, 3, 2, 2, 2, 195, 196, 7, 45, 2, 2, 196,
30, 3, 2, 2, 2, 197, 198, 7, 47, 2, 2, 198, 32, 3, 2, 2, 2, 199, 200, 7,
44, 2, 2, 200, 34, 3, 2, 2, 2, 201, 202, 7, 49, 2, 2, 202, 36, 3, 2, 2,
2, 203, 204, 7, 39, 2, 2, 204, 38, 3, 2, 2, 2, 205, 206, 7, 44, 2, 2, 206,
207, 7, 44, 2, 2, 207, 40, 3, 2, 2, 2, 208, 209, 7, 62, 2, 2, 209, 210,
7, 62, 2, 2, 210, 42, 3, 2, 2, 2, 211, 212, 7, 64, 2, 2, 212, 213, 7, 64,
2, 2, 213, 44, 3, 2, 2, 2, 214, 215, 7, 40, 2, 2, 215, 46, 3, 2, 2, 2,
216, 217, 7, 126, 2, 2, 217, 48, 3, 2, 2, 2, 218, 219, 7, 96, 2, 2, 219,
50, 3, 2, 2, 2, 220, 221, 7, 40, 2, 2, 221, 226, 7, 40, 2, 2, 222, 223,
7, 99, 2, 2, 223, 224, 7, 112, 2, 2, 224, 226, 7, 102, 2, 2, 225, 220,
3, 2, 2, 2, 225, 222, 3, 2, 2, 2, 226, 52, 3, 2, 2, 2, 227, 228, 7, 126,
2, 2, 228, 232, 7, 126, 2, 2, 229, 230, 7, 113, 2, 2, 230, 232, 7, 116,
2, 2, 231, 227, 3, 2, 2, 2, 231, 229, 3, 2, 2, 2, 232, 54, 3, 2, 2, 2,
233, 234, 7, 128, 2, 2, 234, 56, 3, 2, 2, 2, 235, 240, 7, 35, 2, 2, 236,
237, 7, 112, 2, 2, 237, 238, 7, 113, 2, 2, 238, 240, 7, 118, 2, 2, 239,
235, 3, 2, 2, 2, 239, 236, 3, 2, 2, 2, 240, 58, 3, 2, 2, 2, 241, 242, 7,
107, 2, 2, 242, 243, 7, 112, 2, 2, 243, 60, 3, 2, 2, 2, 244, 245, 7, 112,
2, 2, 245, 246, 7, 113, 2, 2, 246, 247, 7, 118, 2, 2, 247, 248, 7, 34,
2, 2, 248, 249, 7, 107, 2, 2, 249, 250, 7, 112, 2, 2, 250, 62, 3, 2, 2,
2, 251, 256, 7, 93, 2, 2, 252, 255, 5, 141, 71, 2, 253, 255, 5, 143, 72,
2, 254, 252, 3, 2, 2, 2, 254, 253, 3, 2, 2, 2, 255, 258, 3, 2, 2, 2, 256,
254, 3, 2, 2, 2, 256, 257, 3, 2, 2, 2, 257, 259, 3, 2, 2, 2, 258, 256,
3, 2, 2, 2, 259, 260, 7, 95, 2, 2, 260, 64, 3, 2, 2, 2, 261, 262, 7, 108,
2, 2, 262, 263, 7, 117, 2, 2, 263, 264, 7, 113, 2, 2, 264, 265, 7, 112,
2, 2, 265, 266, 7, 97, 2, 2, 266, 267, 7, 101, 2, 2, 267, 268, 7, 113,
2, 2, 268, 269, 7, 112, 2, 2, 269, 270, 7, 118, 2, 2, 270, 271, 7, 99,
2, 2, 271, 272, 7, 107, 2, 2, 272, 273, 7, 112, 2, 2, 273, 288, 7, 117,
2, 2, 274, 275, 7, 76, 2, 2, 275, 276, 7, 85, 2, 2, 276, 277, 7, 81, 2,
2, 277, 278, 7, 80, 2, 2, 278, 279, 7, 97, 2, 2, 279, 280, 7, 69, 2, 2,
280, 281, 7, 81, 2, 2, 281, 282, 7, 80, 2, 2, 282, 283, 7, 86, 2, 2, 283,
284, 7, 67, 2, 2, 284, 285, 7, 75, 2, 2, 285, 286, 7, 80, 2, 2, 286, 288,
7, 85, 2, 2, 287, 261, 3, 2, 2, 2, 287, 274, 3, 2, 2, 2, 288, 66, 3, 2,
2, 2, 289, 290, 7, 108, 2, 2, 290, 291, 7, 117, 2, 2, 291, 292, 7, 113,
2, 2, 292, 293, 7, 112, 2, 2, 293, 294, 7, 97, 2, 2, 294, 295, 7, 101,
2, 2, 295, 296, 7, 113, 2, 2, 296, 297, 7, 112, 2, 2, 297, 298, 7, 118,
2, 2, 298, 299, 7, 99, 2, 2, 299, 300, 7, 107, 2, 2, 300, 301, 7, 112,
2, 2, 301, 302, 7, 117, 2, 2, 302, 303, 7, 97, 2, 2, 303, 304, 7, 99, 2,
2, 304, 305, 7, 110, 2, 2, 305, 324, 7, 110, 2, 2, 306, 307, 7, 76, 2,
2, 307, 308, 7, 85, 2, 2, 308, 309, 7, 81, 2, 2, 309, 310, 7, 80, 2, 2,
310, 311, 7, 97, 2, 2, 311, 312, 7, 69, 2, 2, 312, 313, 7, 81, 2, 2, 313,
314, 7, 80, 2, 2, 314, 315, 7, 86, 2, 2, 315, 316, 7, 67, 2, 2, 316, 317,
7, 75, 2, 2, 317, 318, 7, 80, 2, 2, 318, 319, 7, 85, 2, 2, 319, 320, 7,
97, 2, 2, 320, 321, 7, 67, 2, 2, 321, 322, 7, 78, 2, 2, 322, 324, 7, 78,
2, 2, 323, 289, 3, 2, 2, 2, 323, 306, 3, 2, 2, 2, 324, 68, 3, 2, 2, 2,
325, 326, 7, 108, 2, 2, 326, 327, 7, 117, 2, 2, 327, 328, 7, 113, 2, 2,
328, 329, 7, 112, 2, 2, 329, 330, 7, 97, 2, 2, 330, 331, 7, 101, 2, 2,
331, 332, 7, 113, 2, 2, 332, 333, 7, 112, 2, 2, 333, 334, 7, 118, 2, 2,
334, 335, 7, 99, 2, 2, 335, 336, 7, 107, 2, 2, 336, 337, 7, 112, 2, 2,
337, 338, 7, 117, 2, 2, 338, 339, 7, 97, 2, 2, 339, 340, 7, 99, 2, 2, 340,
341, 7, 112, 2, 2, 341, 360, 7, 123, 2, 2, 342, 343, 7, 76, 2, 2, 343,
344, 7, 85, 2, 2, 344, 345, 7, 81, 2, 2, 345, 346, 7, 80, 2, 2, 346, 347,
7, 97, 2, 2, 347, 348, 7, 69, 2, 2, 348, 349, 7, 81, 2, 2, 349, 350, 7,
80, 2, 2, 350, 351, 7, 86, 2, 2, 351, 352, 7, 67, 2, 2, 352, 353, 7, 75,
2, 2, 353, 354, 7, 80, 2, 2, 354, 355, 7, 85, 2, 2, 355, 356, 7, 97, 2,
2, 356, 357, 7, 67, 2, 2, 357, 358, 7, 80, 2, 2, 358, 360, 7, 91, 2, 2,
359, 325, 3, 2, 2, 2, 359, 342, 3, 2, 2, 2, 360, 70, 3, 2, 2, 2, 361, 362,
7, 99, 2, 2, 362, 363, 7, 116, 2, 2, 363, 364, 7, 116, 2, 2, 364, 365,
7, 99, 2, 2, 365, 366, 7, 123, 2, 2, 366, 367, 7, 97, 2, 2, 367, 368, 7,
101, 2, 2, 368, 369, 7, 113, 2, 2, 369, 370, 7, 112, 2, 2, 370, 371, 7,
118, 2, 2, 371, 372, 7, 99, 2, 2, 372, 373, 7, 107, 2, 2, 373, 374, 7,
112, 2, 2, 374, 390, 7, 117, 2, 2, 375, 376, 7, 67, 2, 2, 376, 377, 7,
84, 2, 2, 377, 378, 7, 84, 2, 2, 378, 379, 7, 67, 2, 2, 379, 380, 7, 91,
2, 2, 380, 381, 7, 97, 2, 2, 381, 382, 7, 69, 2, 2, 382, 383, 7, 81, 2,
2, 383, 384, 7, 80, 2, 2, 384, 385, 7, 86, 2, 2, 385, 386, 7, 67, 2, 2,
386, 387, 7, 75, 2, 2, 387, 388, 7, 80, 2, 2, 388, 390, 7, 85, 2, 2, 389,
361, 3, 2, 2, 2, 389, 375, 3, 2, 2, 2, 390, 72, 3, 2, 2, 2, 391, 392, 7,
99, 2, 2, 392, 393, 7, 116, 2, 2, 393, 394, 7, 116, 2, 2, 394, 395, 7,
99, 2, 2, 395, 396, 7, 123, 2, 2, 396, 397, 7, 97, 2, 2, 397, 398, 7, 101,
2, 2, 398, 399, 7, 113, 2, 2, 399, 400, 7, 112, 2, 2, 400, 401, 7, 118,
2, 2, 401, 402, 7, 99, 2, 2, 402, 403, 7, 107, 2, 2, 403, 404, 7, 112,
2, 2, 404, 405, 7, 117, 2, 2, 405, 406, 7, 97, 2, 2, 406, 407, 7, 99, 2,
2, 407, 408, 7, 110, 2, 2, 408, 428, 7, 110, 2, 2, 409, 410, 7, 67, 2,
2, 410, 411, 7, 84, 2, 2, 411, 412, 7, 84, 2, 2, 412, 413, 7, 67, 2, 2,
413, 414, 7, 91, 2, 2, 414, 415, 7, 97, 2, 2, 415, 416, 7, 69, 2, 2, 416,
417, 7, 81, 2, 2, 417, 418, 7, 80, 2, 2, 418, 419, 7, 86, 2, 2, 419, 420,
7, 67, 2, 2, 420, 421, 7, 75, 2, 2, 421, 422, 7, 80, 2, 2, 422, 423, 7,
85, 2, 2, 423, 424, 7, 97, 2, 2, 424, 425, 7, 67, 2, 2, 425, 426, 7, 78,
2, 2, 426, 428, 7, 78, 2, 2, 427, 391, 3, 2, 2, 2, 427, 409, 3, 2, 2, 2,
428, 74, 3, 2, 2, 2, 429, 430, 7, 99, 2, 2, 430, 431, 7, 116, 2, 2, 431,
432, 7, 116, 2, 2, 432, 433, 7, 99, 2, 2, 433, 434, 7, 123, 2, 2, 434,
435, 7, 97, 2, 2, 435, 436, 7, 101, 2, 2, 436, 437, 7, 113, 2, 2, 437,
438, 7, 112, 2, 2, 438, 439, 7, 118, 2, 2, 439, 440, 7, 99, 2, 2, 440,
441, 7, 107, 2, 2, 441, 442, 7, 112, 2, 2, 442, 443, 7, 117, 2, 2, 443,
444, 7, 97, 2, 2, 444, 445, 7, 99, 2, 2, 445, 446, 7, 112, 2, 2, 446, 466,
7, 123, 2, 2, 447, 448, 7, 67, 2, 2, 448, 449, 7, 84, 2, 2, 449, 450, 7,
84, 2, 2, 450, 451, 7, 67, 2, 2, 451, 452, 7, 91, 2, 2, 452, 453, 7, 97,
2, 2, 453, 454, 7, 69, 2, 2, 454, 455, 7, 81, 2, 2, 455, 456, 7, 80, 2,
2, 456, 457, 7, 86, 2, 2, 457, 458, 7, 67, 2, 2, 458, 459, 7, 75, 2, 2,
459, 460, 7, 80, 2, 2, 460, 461, 7, 85, 2, 2, 461, 462, 7, 97, 2, 2, 462,
463, 7, 67, 2, 2, 463, 464, 7, 80, 2, 2, 464, 466, 7, 91, 2, 2, 465, 429,
3, 2, 2, 2, 465, 447, 3, 2, 2, 2, 466, 76, 3, 2, 2, 2, 467, 468, 7, 99,
2, 2, 468, 469, 7, 116, 2, 2, 469, 470, 7, 116, 2, 2, 470, 471, 7, 99,
2, 2, 471, 472, 7, 123, 2, 2, 472, 473, 7, 97, 2, 2, 473, 474, 7, 110,
2, 2, 474, 475, 7, 103, 2, 2, 475, 476, 7, 112, 2, 2, 476, 477, 7, 105,
2, 2, 477, 478, 7, 118, 2, 2, 478, 492, 7, 106, 2, 2, 479, 480, 7, 67,
2, 2, 480, 481, 7, 84, 2, 2, 481, 482, 7, 84, 2, 2, 482, 483, 7, 67, 2,
2, 483, 484, 7, 91, 2, 2, 484, 485, 7, 97, 2, 2, 485, 486, 7, 78, 2, 2,
486, 487, 7, 71, 2, 2, 487, 488, 7, 80, 2, 2, 488, 489, 7, 73, 2, 2, 489,
490, 7, 86, 2, 2, 490, 492, 7, 74, 2, 2, 491, 467, 3, 2, 2, 2, 491, 479,
3, 2, 2, 2, 492, 78, 3, 2, 2, 2, 493, 494, 7, 118, 2, 2, 494, 495, 7, 116,
2, 2, 495, 496, 7, 119, 2, 2, 496, 521, 7, 103, 2, 2, 497, 498, 7, 86,
2, 2, 498, 499, 7, 116, 2, 2, 499, 500, 7, 119, 2, 2, 500, 521, 7, 103,
2, 2, 501, 502, 7, 86, 2, 2, 502, 503, 7, 84, 2, 2, 503, 504, 7, 87, 2,
2, 504, 521, 7, 71, 2, 2, 505, 506, 7, 104, 2, 2, 506, 507, 7, 99, 2, 2,
507, 508, 7, 110, 2, 2, 508, 509, 7, 117, 2, 2, 509, 521, 7, 103, 2, 2,
510, 511, 7, 72, 2, 2, 511, 512, 7, 99, 2, 2, 512, 513, 7, 110, 2, 2, 513,
514, 7, 117, 2, 2, 514, 521, 7, 103, 2, 2, 515, 516, 7, 72, 2, 2, 516,
517, 7, 67, 2, 2, 517, 518, 7, 78, 2, 2, 518, 519, 7, 85, 2, 2, 519, 521,
7, 71, 2, 2, 520, 493, 3, 2, 2, 2, 520, 497, 3, 2, 2, 2, 520, 501, 3, 2,
2, 2, 520, 505, 3, 2, 2, 2, 520, 510, 3, 2, 2, 2, 520, 515, 3, 2, 2, 2,
521, 80, 3, 2, 2, 2, 522, 527, 5, 107, 54, 2, 523, 527, 5, 109, 55, 2,
524, 527, 5, 111, 56, 2, 525, 527, 5, 105, 53, 2, 526, 522, 3, 2, 2, 2,
526, 523, 3, 2, 2, 2, 526, 524, 3, 2, 2, 2, 526, 525, 3, 2, 2, 2, 527,
82, 3, 2, 2, 2, 528, 531, 5, 123, 62, 2, 529, 531, 5, 125, 63, 2, 530,
528, 3, 2, 2, 2, 530, 529, 3, 2, 2, 2, 531, 84, 3, 2, 2, 2, 532, 537, 5,
101, 51, 2, 533, 536, 5, 101, 51, 2, 534, 536, 5, 103, 52, 2, 535, 533,
3, 2, 2, 2, 535, 534, 3, 2, 2, 2, 536, 539, 3, 2, 2, 2, 537, 535, 3, 2,
2, 2, 537, 538, 3, 2, 2, 2, 538, 546, 3, 2, 2, 2, 539, 537, 3, 2, 2, 2,
540, 541, 7, 38, 2, 2, 541, 542, 7, 111, 2, 2, 542, 543, 7, 103, 2, 2,
543, 544, 7, 118, 2, 2, 544, 546, 7, 99, 2, 2, 545, 532, 3, 2, 2, 2, 545,
540, 3, 2, 2, 2, 546, 86, 3, 2, 2, 2, 547, 549, 5, 91, 46, 2, 548, 547,
3, 2, 2, 2, 548, 549, 3, 2, 2, 2, 549, 560, 3, 2, 2, 2, 550, 552, 7, 36,
2, 2, 551, 553, 5, 93, 47, 2, 552, 551, 3, 2, 2, 2, 552, 553, 3, 2, 2,
2, 553, 554, 3, 2, 2, 2, 554, 561, 7, 36, 2, 2, 555, 557, 7, 41, 2, 2,
556, 558, 5, 95, 48, 2, 557, 556, 3, 2, 2, 2, 557, 558, 3, 2, 2, 2, 558,
559, 3, 2, 2, 2, 559, 561, 7, 41, 2, 2, 560, 550, 3, 2, 2, 2, 560, 555,
3, 2, 2, 2, 561, 88, 3, 2, 2, 2, 562, 570, 5, 85, 43, 2, 563, 566, 7, 93,
2, 2, 564, 567, 5, 87, 44, 2, 565, 567, 5, 107, 54, 2, 566, 564, 3, 2,
2, 2, 566, 565, 3, 2, 2, 2, 567, 568, 3, 2, 2, 2, 568, 569, 7, 95, 2, 2,
569, 571, 3, 2, 2, 2, 570, 563, 3, 2, 2, 2, 571, 572, 3, 2, 2, 2, 572,
570, 3, 2, 2, 2, 572, 573, 3, 2, 2, 2, 573, 90, 3, 2, 2, 2, 574, 575, 7,
119, 2, 2, 575, 578, 7, 58, 2, 2, 576, 578, 9, 2, 2, 2, 577, 574, 3, 2,
2, 2, 577, 576, 3, 2, 2, 2, 578, 92, 3, 2, 2, 2, 579, 581, 5, 97, 49, 2,
580, 579, 3, 2, 2, 2, 581, 582, 3, 2, 2, 2, 582, 580, 3, 2, 2, 2, 582,
583, 3, 2, 2, 2, 583, 94, 3, 2, 2, 2, 584, 586, 5, 99, 50, 2, 585, 584,
3, 2, 2, 2, 586, 587, 3, 2, 2, 2, 587, 585, 3, 2, 2, 2, 587, 588, 3, 2,
2, 2, 588, 96, 3, 2, 2, 2, 589, 597, 10, 3, 2, 2, 590, 597, 5, 139, 70,
2, 591, 592, 7, 94, 2, 2, 592, 597, 7, 12, 2, 2, 593, 594, 7, 94, 2, 2,
594, 595, 7, 15, 2, 2, 595, 597, 7, 12, 2, 2, 596, 589, 3, 2, 2, 2, 596,
590, 3, 2, 2, 2, 596, 591, 3, 2, 2, 2, 596, 593, 3, 2, 2, 2, 597, 98, 3,
2, 2, 2, 598, 606, 10, 4, 2, 2, 599, 606, 5, 139, 70, 2, 600, 601, 7, 94,
2, 2, 601, 606, 7, 12, 2, 2, 602, 603, 7, 94, 2, 2, 603, 604, 7, 15, 2,
2, 604, 606, 7, 12, 2, 2, 605, 598, 3, 2, 2, 2, 605, 599, 3, 2, 2, 2, 605,
600, 3, 2, 2, 2, 605, 602, 3, 2, 2, 2, 606, 100, 3, 2, 2, 2, 607, 608,
9, 5, 2, 2, 608, 102, 3, 2, 2, 2, 609, 610, 9, 6, 2, 2, 610, 104, 3, 2,
2, 2, 611, 612, 7, 50, 2, 2, 612, 614, 9, 7, 2, 2, 613, 615, 9, 8, 2, 2,
614, 613, 3, 2, 2, 2, 615, 616, 3, 2, 2, 2, 616, 614, 3, 2, 2, 2, 616,
617, 3, 2, 2, 2, 617, 106, 3, 2, 2, 2, 618, 622, 5, 113, 57, 2, 619, 621,
5, 103, 52, 2, 620, 619, 3, 2, 2, 2, 621, 624, 3, 2, 2, 2, 622, 620, 3,
2, 2, 2, 622, 623, 3, 2, 2, 2, 623, 627, 3, 2, 2, 2, 624, 622, 3, 2, 2,
2, 625, 627, 7, 50, 2, 2, 626, 618, 3, 2, 2, 2, 626, 625, 3, 2, 2, 2, 627,
108, 3, 2, 2, 2, 628, 632, 7, 50, 2, 2, 629, 631, 5, 115, 58, 2, 630, 629,
3, 2, 2, 2, 631, 634, 3, 2, 2, 2, 632, 630, 3, 2, 2, 2, 632, 633, 3, 2,
2, 2, 633, 110, 3, 2, 2, 2, 634, 632, 3, 2, 2, 2, 635, 636, 7, 50, 2, 2,
636, 637, 9, 9, 2, 2, 637, 638, 5, 135, 68, 2, 638, 112, 3, 2, 2, 2, 639,
640, 9, 10, 2, 2, 640, 114, 3, 2, 2, 2, 641, 642, 9, 11, 2, 2, 642, 116,
3, 2, 2, 2, 643, 644, 9, 12, 2, 2, 644, 118, 3, 2, 2, 2, 645, 646, 5, 117,
59, 2, 646, 647, 5, 117, 59, 2, 647, 648, 5, 117, 59, 2, 648, 649, 5, 117,
59, 2, 649, 120, 3, 2, 2, 2, 650, 651, 7, 94, 2, 2, 651, 652, 7, 119, 2,
2, 652, 653, 3, 2, 2, 2, 653, 661, 5, 119, 60, 2, 654, 655, 7, 94, 2, 2,
655, 656, 7, 87, 2, 2, 656, 657, 3, 2, 2, 2, 657, 658, 5, 119, 60, 2, 658,
659, 5, 119, 60, 2, 659, 661, 3, 2, 2, 2, 660, 650, 3, 2, 2, 2, 660, 654,
3, 2, 2, 2, 661, 122, 3, 2, 2, 2, 662, 664, 5, 127, 64, 2, 663, 665, 5,
129, 65, 2, 664, 663, 3, 2, 2, 2, 664, 665, 3, 2, 2, 2, 665, 670, 3, 2,
2, 2, 666, 667, 5, 131, 66, 2, 667, 668, 5, 129, 65, 2, 668, 670, 3, 2,
2, 2, 669, 662, 3, 2, 2, 2, 669, 666, 3, 2, 2, 2, 670, 124, 3, 2, 2, 2,
671, 672, 7, 50, 2, 2, 672, 675, 9, 9, 2, 2, 673, 676, 5, 133, 67, 2, 674,
676, 5, 135, 68, 2, 675, 673, 3, 2, 2, 2, 675, 674, 3, 2, 2, 2, 676, 677,
3, 2, 2, 2, 677, 678, 5, 137, 69, 2, 678, 126, 3, 2, 2, 2, 679, 681, 5,
131, 66, 2, 680, 679, 3, 2, 2, 2, 680, 681, 3, 2, 2, 2, 681, 682, 3, 2,
2, 2, 682, 683, 7, 48, 2, 2, 683, 688, 5, 131, 66, 2, 684, 685, 5, 131,
66, 2, 685, 686, 7, 48, 2, 2, 686, 688, 3, 2, 2, 2, 687, 680, 3, 2, 2,
2, 687, 684, 3, 2, 2, 2, 688, 128, 3, 2, 2, 2, 689, 691, 9, 13, 2, 2, 690,
692, 9, 14, 2, 2, 691, 690, 3, 2, 2, 2, 691, 692, 3, 2, 2, 2, 692, 693,
3, 2, 2, 2, 693, 694, 5, 131, 66, 2, 694, 130, 3, 2, 2, 2, 695, 697, 5,
103, 52, 2, 696, 695, 3, 2, 2, 2, 697, 698, 3, 2, 2, 2, 698, 696, 3, 2,
2, 2, 698, 699, 3, 2, 2, 2, 699, 132, 3, 2, 2, 2, 700, 702, 5, 135, 68,
2, 701, 700, 3, 2, 2, 2, 701, 702, 3, 2, 2, 2, 702, 703, 3, 2, 2, 2, 703,
704, 7, 48, 2, 2, 704, 709, 5, 135, 68, 2, 705, 706, 5, 135, 68, 2, 706,
707, 7, 48, 2, 2, 707, 709, 3, 2, 2, 2, 708, 701, 3, 2, 2, 2, 708, 705,
3, 2, 2, 2, 709, 134, 3, 2, 2, 2, 710, 712, 5, 117, 59, 2, 711, 710, 3,
2, 2, 2, 712, 713, 3, 2, 2, 2, 713, 711, 3, 2, 2, 2, 713, 714, 3, 2, 2,
2, 714, 136, 3, 2, 2, 2, 715, 717, 9, 15, 2, 2, 716, 718, 9, 14, 2, 2,
717, 716, 3, 2, 2, 2, 717, 718, 3, 2, 2, 2, 718, 719, 3, 2, 2, 2, 719,
720, 5, 131, 66, 2, 720, 138, 3, 2, 2, 2, 721, 722, 7, 94, 2, 2, 722, 737,
9, 16, 2, 2, 723, 724, 7, 94, 2, 2, 724, 726, 5, 115, 58, 2, 725, 727,
5, 115, 58, 2, 726, 725, 3, 2, 2, 2, 726, 727, 3, 2, 2, 2, 727, 729, 3,
2, 2, 2, 728, 730, 5, 115, 58, 2, 729, 728, 3, 2, 2, 2, 729, 730, 3, 2,
2, 2, 730, 737, 3, 2, 2, 2, 731, 732, 7, 94, 2, 2, 732, 733, 7, 122, 2,
2, 733, 734, 3, 2, 2, 2, 734, 737, 5, 135, 68, 2, 735, 737, 5, 121, 61,
2, 736, 721, 3, 2, 2, 2, 736, 723, 3, 2, 2, 2, 736, 731, 3, 2, 2, 2, 736,
735, 3, 2, 2, 2, 737, 140, 3, 2, 2, 2, 738, 740, 9, 17, 2, 2, 739, 738,
3, 2, 2, 2, 740, 741, 3, 2, 2, 2, 741, 739, 3, 2, 2, 2, 741, 742, 3, 2,
2, 2, 742, 743, 3, 2, 2, 2, 743, 744, 8, 71, 2, 2, 744, 142, 3, 2, 2, 2,
745, 747, 7, 15, 2, 2, 746, 748, 7, 12, 2, 2, 747, 746, 3, 2, 2, 2, 747,
748, 3, 2, 2, 2, 748, 751, 3, 2, 2, 2, 749, 751, 7, 12, 2, 2, 750, 745,
3, 2, 2, 2, 750, 749, 3, 2, 2, 2, 751, 752, 3, 2, 2, 2, 752, 753, 8, 72,
2, 2, 753, 144, 3, 2, 2, 2, 56, 2, 179, 193, 225, 231, 239, 254, 256, 287,
323, 359, 389, 427, 465, 491, 520, 526, 530, 535, 537, 545, 548, 552, 557,
560, 566, 572, 577, 582, 587, 596, 605, 616, 622, 626, 632, 660, 664, 669,
675, 680, 687, 691, 698, 701, 708, 713, 717, 726, 729, 736, 741, 747, 750,
3, 8, 2, 2,
40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 5, 40,
496, 10, 40, 3, 41, 3, 41, 3, 41, 3, 41, 3, 41, 3, 41, 3, 41, 3, 41, 3,
41, 3, 41, 3, 41, 3, 41, 3, 41, 3, 41, 3, 41, 3, 41, 3, 41, 3, 41, 3, 41,
3, 41, 3, 41, 3, 41, 3, 41, 3, 41, 3, 41, 3, 41, 3, 41, 5, 41, 525, 10,
41, 3, 42, 3, 42, 3, 42, 3, 42, 5, 42, 531, 10, 42, 3, 43, 3, 43, 5, 43,
535, 10, 43, 3, 44, 3, 44, 3, 44, 7, 44, 540, 10, 44, 12, 44, 14, 44, 543,
11, 44, 3, 45, 3, 45, 3, 45, 3, 45, 3, 45, 3, 45, 3, 46, 5, 46, 552, 10,
46, 3, 46, 3, 46, 5, 46, 556, 10, 46, 3, 46, 3, 46, 3, 46, 5, 46, 561,
10, 46, 3, 46, 5, 46, 564, 10, 46, 3, 47, 3, 47, 5, 47, 568, 10, 47, 3,
47, 3, 47, 3, 47, 5, 47, 573, 10, 47, 3, 47, 3, 47, 6, 47, 577, 10, 47,
13, 47, 14, 47, 578, 3, 48, 3, 48, 3, 48, 5, 48, 584, 10, 48, 3, 49, 6,
49, 587, 10, 49, 13, 49, 14, 49, 588, 3, 50, 6, 50, 592, 10, 50, 13, 50,
14, 50, 593, 3, 51, 3, 51, 3, 51, 3, 51, 3, 51, 3, 51, 3, 51, 5, 51, 603,
10, 51, 3, 52, 3, 52, 3, 52, 3, 52, 3, 52, 3, 52, 3, 52, 5, 52, 612, 10,
52, 3, 53, 3, 53, 3, 54, 3, 54, 3, 55, 3, 55, 3, 55, 6, 55, 621, 10, 55,
13, 55, 14, 55, 622, 3, 56, 3, 56, 7, 56, 627, 10, 56, 12, 56, 14, 56,
630, 11, 56, 3, 56, 5, 56, 633, 10, 56, 3, 57, 3, 57, 7, 57, 637, 10, 57,
12, 57, 14, 57, 640, 11, 57, 3, 58, 3, 58, 3, 58, 3, 58, 3, 59, 3, 59,
3, 60, 3, 60, 3, 61, 3, 61, 3, 62, 3, 62, 3, 62, 3, 62, 3, 62, 3, 63, 3,
63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 5, 63, 667,
10, 63, 3, 64, 3, 64, 5, 64, 671, 10, 64, 3, 64, 3, 64, 3, 64, 5, 64, 676,
10, 64, 3, 65, 3, 65, 3, 65, 3, 65, 5, 65, 682, 10, 65, 3, 65, 3, 65, 3,
66, 5, 66, 687, 10, 66, 3, 66, 3, 66, 3, 66, 3, 66, 3, 66, 5, 66, 694,
10, 66, 3, 67, 3, 67, 5, 67, 698, 10, 67, 3, 67, 3, 67, 3, 68, 6, 68, 703,
10, 68, 13, 68, 14, 68, 704, 3, 69, 5, 69, 708, 10, 69, 3, 69, 3, 69, 3,
69, 3, 69, 3, 69, 5, 69, 715, 10, 69, 3, 70, 6, 70, 718, 10, 70, 13, 70,
14, 70, 719, 3, 71, 3, 71, 5, 71, 724, 10, 71, 3, 71, 3, 71, 3, 72, 3,
72, 3, 72, 3, 72, 3, 72, 5, 72, 733, 10, 72, 3, 72, 5, 72, 736, 10, 72,
3, 72, 3, 72, 3, 72, 3, 72, 3, 72, 5, 72, 743, 10, 72, 3, 73, 6, 73, 746,
10, 73, 13, 73, 14, 73, 747, 3, 73, 3, 73, 3, 74, 3, 74, 5, 74, 754, 10,
74, 3, 74, 5, 74, 757, 10, 74, 3, 74, 3, 74, 2, 2, 75, 3, 3, 5, 4, 7, 5,
9, 6, 11, 7, 13, 8, 15, 9, 17, 10, 19, 11, 21, 12, 23, 13, 25, 14, 27,
15, 29, 16, 31, 17, 33, 18, 35, 19, 37, 20, 39, 21, 41, 22, 43, 23, 45,
24, 47, 25, 49, 26, 51, 27, 53, 28, 55, 29, 57, 30, 59, 31, 61, 32, 63,
33, 65, 34, 67, 35, 69, 36, 71, 37, 73, 38, 75, 39, 77, 40, 79, 41, 81,
42, 83, 43, 85, 44, 87, 45, 89, 46, 91, 47, 93, 48, 95, 2, 97, 2, 99, 2,
101, 2, 103, 2, 105, 2, 107, 2, 109, 2, 111, 2, 113, 2, 115, 2, 117, 2,
119, 2, 121, 2, 123, 2, 125, 2, 127, 2, 129, 2, 131, 2, 133, 2, 135, 2,
137, 2, 139, 2, 141, 2, 143, 2, 145, 49, 147, 50, 3, 2, 18, 5, 2, 78, 78,
87, 87, 119, 119, 6, 2, 12, 12, 15, 15, 36, 36, 94, 94, 6, 2, 12, 12, 15,
15, 41, 41, 94, 94, 5, 2, 67, 92, 97, 97, 99, 124, 3, 2, 50, 59, 4, 2,
68, 68, 100, 100, 3, 2, 50, 51, 4, 2, 90, 90, 122, 122, 3, 2, 51, 59, 3,
2, 50, 57, 5, 2, 50, 59, 67, 72, 99, 104, 4, 2, 71, 71, 103, 103, 4, 2,
45, 45, 47, 47, 4, 2, 82, 82, 114, 114, 12, 2, 36, 36, 41, 41, 65, 65,
94, 94, 99, 100, 104, 104, 112, 112, 116, 116, 118, 118, 120, 120, 4, 2,
11, 11, 34, 34, 2, 800, 2, 3, 3, 2, 2, 2, 2, 5, 3, 2, 2, 2, 2, 7, 3, 2,
2, 2, 2, 9, 3, 2, 2, 2, 2, 11, 3, 2, 2, 2, 2, 13, 3, 2, 2, 2, 2, 15, 3,
2, 2, 2, 2, 17, 3, 2, 2, 2, 2, 19, 3, 2, 2, 2, 2, 21, 3, 2, 2, 2, 2, 23,
3, 2, 2, 2, 2, 25, 3, 2, 2, 2, 2, 27, 3, 2, 2, 2, 2, 29, 3, 2, 2, 2, 2,
31, 3, 2, 2, 2, 2, 33, 3, 2, 2, 2, 2, 35, 3, 2, 2, 2, 2, 37, 3, 2, 2, 2,
2, 39, 3, 2, 2, 2, 2, 41, 3, 2, 2, 2, 2, 43, 3, 2, 2, 2, 2, 45, 3, 2, 2,
2, 2, 47, 3, 2, 2, 2, 2, 49, 3, 2, 2, 2, 2, 51, 3, 2, 2, 2, 2, 53, 3, 2,
2, 2, 2, 55, 3, 2, 2, 2, 2, 57, 3, 2, 2, 2, 2, 59, 3, 2, 2, 2, 2, 61, 3,
2, 2, 2, 2, 63, 3, 2, 2, 2, 2, 65, 3, 2, 2, 2, 2, 67, 3, 2, 2, 2, 2, 69,
3, 2, 2, 2, 2, 71, 3, 2, 2, 2, 2, 73, 3, 2, 2, 2, 2, 75, 3, 2, 2, 2, 2,
77, 3, 2, 2, 2, 2, 79, 3, 2, 2, 2, 2, 81, 3, 2, 2, 2, 2, 83, 3, 2, 2, 2,
2, 85, 3, 2, 2, 2, 2, 87, 3, 2, 2, 2, 2, 89, 3, 2, 2, 2, 2, 91, 3, 2, 2,
2, 2, 93, 3, 2, 2, 2, 2, 145, 3, 2, 2, 2, 2, 147, 3, 2, 2, 2, 3, 149, 3,
2, 2, 2, 5, 151, 3, 2, 2, 2, 7, 153, 3, 2, 2, 2, 9, 155, 3, 2, 2, 2, 11,
157, 3, 2, 2, 2, 13, 159, 3, 2, 2, 2, 15, 161, 3, 2, 2, 2, 17, 163, 3,
2, 2, 2, 19, 165, 3, 2, 2, 2, 21, 168, 3, 2, 2, 2, 23, 170, 3, 2, 2, 2,
25, 173, 3, 2, 2, 2, 27, 176, 3, 2, 2, 2, 29, 187, 3, 2, 2, 2, 31, 201,
3, 2, 2, 2, 33, 203, 3, 2, 2, 2, 35, 205, 3, 2, 2, 2, 37, 207, 3, 2, 2,
2, 39, 209, 3, 2, 2, 2, 41, 211, 3, 2, 2, 2, 43, 213, 3, 2, 2, 2, 45, 216,
3, 2, 2, 2, 47, 219, 3, 2, 2, 2, 49, 222, 3, 2, 2, 2, 51, 224, 3, 2, 2,
2, 53, 226, 3, 2, 2, 2, 55, 233, 3, 2, 2, 2, 57, 239, 3, 2, 2, 2, 59, 241,
3, 2, 2, 2, 61, 247, 3, 2, 2, 2, 63, 253, 3, 2, 2, 2, 65, 255, 3, 2, 2,
2, 67, 291, 3, 2, 2, 2, 69, 327, 3, 2, 2, 2, 71, 363, 3, 2, 2, 2, 73, 393,
3, 2, 2, 2, 75, 431, 3, 2, 2, 2, 77, 469, 3, 2, 2, 2, 79, 495, 3, 2, 2,
2, 81, 524, 3, 2, 2, 2, 83, 530, 3, 2, 2, 2, 85, 534, 3, 2, 2, 2, 87, 536,
3, 2, 2, 2, 89, 544, 3, 2, 2, 2, 91, 551, 3, 2, 2, 2, 93, 567, 3, 2, 2,
2, 95, 583, 3, 2, 2, 2, 97, 586, 3, 2, 2, 2, 99, 591, 3, 2, 2, 2, 101,
602, 3, 2, 2, 2, 103, 611, 3, 2, 2, 2, 105, 613, 3, 2, 2, 2, 107, 615,
3, 2, 2, 2, 109, 617, 3, 2, 2, 2, 111, 632, 3, 2, 2, 2, 113, 634, 3, 2,
2, 2, 115, 641, 3, 2, 2, 2, 117, 645, 3, 2, 2, 2, 119, 647, 3, 2, 2, 2,
121, 649, 3, 2, 2, 2, 123, 651, 3, 2, 2, 2, 125, 666, 3, 2, 2, 2, 127,
675, 3, 2, 2, 2, 129, 677, 3, 2, 2, 2, 131, 693, 3, 2, 2, 2, 133, 695,
3, 2, 2, 2, 135, 702, 3, 2, 2, 2, 137, 714, 3, 2, 2, 2, 139, 717, 3, 2,
2, 2, 141, 721, 3, 2, 2, 2, 143, 742, 3, 2, 2, 2, 145, 745, 3, 2, 2, 2,
147, 756, 3, 2, 2, 2, 149, 150, 7, 42, 2, 2, 150, 4, 3, 2, 2, 2, 151, 152,
7, 43, 2, 2, 152, 6, 3, 2, 2, 2, 153, 154, 7, 93, 2, 2, 154, 8, 3, 2, 2,
2, 155, 156, 7, 46, 2, 2, 156, 10, 3, 2, 2, 2, 157, 158, 7, 95, 2, 2, 158,
12, 3, 2, 2, 2, 159, 160, 7, 125, 2, 2, 160, 14, 3, 2, 2, 2, 161, 162,
7, 127, 2, 2, 162, 16, 3, 2, 2, 2, 163, 164, 7, 62, 2, 2, 164, 18, 3, 2,
2, 2, 165, 166, 7, 62, 2, 2, 166, 167, 7, 63, 2, 2, 167, 20, 3, 2, 2, 2,
168, 169, 7, 64, 2, 2, 169, 22, 3, 2, 2, 2, 170, 171, 7, 64, 2, 2, 171,
172, 7, 63, 2, 2, 172, 24, 3, 2, 2, 2, 173, 174, 7, 63, 2, 2, 174, 175,
7, 63, 2, 2, 175, 26, 3, 2, 2, 2, 176, 177, 7, 35, 2, 2, 177, 178, 7, 63,
2, 2, 178, 28, 3, 2, 2, 2, 179, 180, 7, 110, 2, 2, 180, 181, 7, 107, 2,
2, 181, 182, 7, 109, 2, 2, 182, 188, 7, 103, 2, 2, 183, 184, 7, 78, 2,
2, 184, 185, 7, 75, 2, 2, 185, 186, 7, 77, 2, 2, 186, 188, 7, 71, 2, 2,
187, 179, 3, 2, 2, 2, 187, 183, 3, 2, 2, 2, 188, 30, 3, 2, 2, 2, 189, 190,
7, 103, 2, 2, 190, 191, 7, 122, 2, 2, 191, 192, 7, 107, 2, 2, 192, 193,
7, 117, 2, 2, 193, 194, 7, 118, 2, 2, 194, 202, 7, 117, 2, 2, 195, 196,
7, 71, 2, 2, 196, 197, 7, 90, 2, 2, 197, 198, 7, 75, 2, 2, 198, 199, 7,
85, 2, 2, 199, 200, 7, 86, 2, 2, 200, 202, 7, 85, 2, 2, 201, 189, 3, 2,
2, 2, 201, 195, 3, 2, 2, 2, 202, 32, 3, 2, 2, 2, 203, 204, 7, 45, 2, 2,
204, 34, 3, 2, 2, 2, 205, 206, 7, 47, 2, 2, 206, 36, 3, 2, 2, 2, 207, 208,
7, 44, 2, 2, 208, 38, 3, 2, 2, 2, 209, 210, 7, 49, 2, 2, 210, 40, 3, 2,
2, 2, 211, 212, 7, 39, 2, 2, 212, 42, 3, 2, 2, 2, 213, 214, 7, 44, 2, 2,
214, 215, 7, 44, 2, 2, 215, 44, 3, 2, 2, 2, 216, 217, 7, 62, 2, 2, 217,
218, 7, 62, 2, 2, 218, 46, 3, 2, 2, 2, 219, 220, 7, 64, 2, 2, 220, 221,
7, 64, 2, 2, 221, 48, 3, 2, 2, 2, 222, 223, 7, 40, 2, 2, 223, 50, 3, 2,
2, 2, 224, 225, 7, 126, 2, 2, 225, 52, 3, 2, 2, 2, 226, 227, 7, 96, 2,
2, 227, 54, 3, 2, 2, 2, 228, 229, 7, 40, 2, 2, 229, 234, 7, 40, 2, 2, 230,
231, 7, 99, 2, 2, 231, 232, 7, 112, 2, 2, 232, 234, 7, 102, 2, 2, 233,
228, 3, 2, 2, 2, 233, 230, 3, 2, 2, 2, 234, 56, 3, 2, 2, 2, 235, 236, 7,
126, 2, 2, 236, 240, 7, 126, 2, 2, 237, 238, 7, 113, 2, 2, 238, 240, 7,
116, 2, 2, 239, 235, 3, 2, 2, 2, 239, 237, 3, 2, 2, 2, 240, 58, 3, 2, 2,
2, 241, 242, 7, 128, 2, 2, 242, 60, 3, 2, 2, 2, 243, 248, 7, 35, 2, 2,
244, 245, 7, 112, 2, 2, 245, 246, 7, 113, 2, 2, 246, 248, 7, 118, 2, 2,
247, 243, 3, 2, 2, 2, 247, 244, 3, 2, 2, 2, 248, 62, 3, 2, 2, 2, 249, 250,
7, 107, 2, 2, 250, 254, 7, 112, 2, 2, 251, 252, 7, 75, 2, 2, 252, 254,
7, 80, 2, 2, 253, 249, 3, 2, 2, 2, 253, 251, 3, 2, 2, 2, 254, 64, 3, 2,
2, 2, 255, 260, 7, 93, 2, 2, 256, 259, 5, 145, 73, 2, 257, 259, 5, 147,
74, 2, 258, 256, 3, 2, 2, 2, 258, 257, 3, 2, 2, 2, 259, 262, 3, 2, 2, 2,
260, 258, 3, 2, 2, 2, 260, 261, 3, 2, 2, 2, 261, 263, 3, 2, 2, 2, 262,
260, 3, 2, 2, 2, 263, 264, 7, 95, 2, 2, 264, 66, 3, 2, 2, 2, 265, 266,
7, 108, 2, 2, 266, 267, 7, 117, 2, 2, 267, 268, 7, 113, 2, 2, 268, 269,
7, 112, 2, 2, 269, 270, 7, 97, 2, 2, 270, 271, 7, 101, 2, 2, 271, 272,
7, 113, 2, 2, 272, 273, 7, 112, 2, 2, 273, 274, 7, 118, 2, 2, 274, 275,
7, 99, 2, 2, 275, 276, 7, 107, 2, 2, 276, 277, 7, 112, 2, 2, 277, 292,
7, 117, 2, 2, 278, 279, 7, 76, 2, 2, 279, 280, 7, 85, 2, 2, 280, 281, 7,
81, 2, 2, 281, 282, 7, 80, 2, 2, 282, 283, 7, 97, 2, 2, 283, 284, 7, 69,
2, 2, 284, 285, 7, 81, 2, 2, 285, 286, 7, 80, 2, 2, 286, 287, 7, 86, 2,
2, 287, 288, 7, 67, 2, 2, 288, 289, 7, 75, 2, 2, 289, 290, 7, 80, 2, 2,
290, 292, 7, 85, 2, 2, 291, 265, 3, 2, 2, 2, 291, 278, 3, 2, 2, 2, 292,
68, 3, 2, 2, 2, 293, 294, 7, 108, 2, 2, 294, 295, 7, 117, 2, 2, 295, 296,
7, 113, 2, 2, 296, 297, 7, 112, 2, 2, 297, 298, 7, 97, 2, 2, 298, 299,
7, 101, 2, 2, 299, 300, 7, 113, 2, 2, 300, 301, 7, 112, 2, 2, 301, 302,
7, 118, 2, 2, 302, 303, 7, 99, 2, 2, 303, 304, 7, 107, 2, 2, 304, 305,
7, 112, 2, 2, 305, 306, 7, 117, 2, 2, 306, 307, 7, 97, 2, 2, 307, 308,
7, 99, 2, 2, 308, 309, 7, 110, 2, 2, 309, 328, 7, 110, 2, 2, 310, 311,
7, 76, 2, 2, 311, 312, 7, 85, 2, 2, 312, 313, 7, 81, 2, 2, 313, 314, 7,
80, 2, 2, 314, 315, 7, 97, 2, 2, 315, 316, 7, 69, 2, 2, 316, 317, 7, 81,
2, 2, 317, 318, 7, 80, 2, 2, 318, 319, 7, 86, 2, 2, 319, 320, 7, 67, 2,
2, 320, 321, 7, 75, 2, 2, 321, 322, 7, 80, 2, 2, 322, 323, 7, 85, 2, 2,
323, 324, 7, 97, 2, 2, 324, 325, 7, 67, 2, 2, 325, 326, 7, 78, 2, 2, 326,
328, 7, 78, 2, 2, 327, 293, 3, 2, 2, 2, 327, 310, 3, 2, 2, 2, 328, 70,
3, 2, 2, 2, 329, 330, 7, 108, 2, 2, 330, 331, 7, 117, 2, 2, 331, 332, 7,
113, 2, 2, 332, 333, 7, 112, 2, 2, 333, 334, 7, 97, 2, 2, 334, 335, 7,
101, 2, 2, 335, 336, 7, 113, 2, 2, 336, 337, 7, 112, 2, 2, 337, 338, 7,
118, 2, 2, 338, 339, 7, 99, 2, 2, 339, 340, 7, 107, 2, 2, 340, 341, 7,
112, 2, 2, 341, 342, 7, 117, 2, 2, 342, 343, 7, 97, 2, 2, 343, 344, 7,
99, 2, 2, 344, 345, 7, 112, 2, 2, 345, 364, 7, 123, 2, 2, 346, 347, 7,
76, 2, 2, 347, 348, 7, 85, 2, 2, 348, 349, 7, 81, 2, 2, 349, 350, 7, 80,
2, 2, 350, 351, 7, 97, 2, 2, 351, 352, 7, 69, 2, 2, 352, 353, 7, 81, 2,
2, 353, 354, 7, 80, 2, 2, 354, 355, 7, 86, 2, 2, 355, 356, 7, 67, 2, 2,
356, 357, 7, 75, 2, 2, 357, 358, 7, 80, 2, 2, 358, 359, 7, 85, 2, 2, 359,
360, 7, 97, 2, 2, 360, 361, 7, 67, 2, 2, 361, 362, 7, 80, 2, 2, 362, 364,
7, 91, 2, 2, 363, 329, 3, 2, 2, 2, 363, 346, 3, 2, 2, 2, 364, 72, 3, 2,
2, 2, 365, 366, 7, 99, 2, 2, 366, 367, 7, 116, 2, 2, 367, 368, 7, 116,
2, 2, 368, 369, 7, 99, 2, 2, 369, 370, 7, 123, 2, 2, 370, 371, 7, 97, 2,
2, 371, 372, 7, 101, 2, 2, 372, 373, 7, 113, 2, 2, 373, 374, 7, 112, 2,
2, 374, 375, 7, 118, 2, 2, 375, 376, 7, 99, 2, 2, 376, 377, 7, 107, 2,
2, 377, 378, 7, 112, 2, 2, 378, 394, 7, 117, 2, 2, 379, 380, 7, 67, 2,
2, 380, 381, 7, 84, 2, 2, 381, 382, 7, 84, 2, 2, 382, 383, 7, 67, 2, 2,
383, 384, 7, 91, 2, 2, 384, 385, 7, 97, 2, 2, 385, 386, 7, 69, 2, 2, 386,
387, 7, 81, 2, 2, 387, 388, 7, 80, 2, 2, 388, 389, 7, 86, 2, 2, 389, 390,
7, 67, 2, 2, 390, 391, 7, 75, 2, 2, 391, 392, 7, 80, 2, 2, 392, 394, 7,
85, 2, 2, 393, 365, 3, 2, 2, 2, 393, 379, 3, 2, 2, 2, 394, 74, 3, 2, 2,
2, 395, 396, 7, 99, 2, 2, 396, 397, 7, 116, 2, 2, 397, 398, 7, 116, 2,
2, 398, 399, 7, 99, 2, 2, 399, 400, 7, 123, 2, 2, 400, 401, 7, 97, 2, 2,
401, 402, 7, 101, 2, 2, 402, 403, 7, 113, 2, 2, 403, 404, 7, 112, 2, 2,
404, 405, 7, 118, 2, 2, 405, 406, 7, 99, 2, 2, 406, 407, 7, 107, 2, 2,
407, 408, 7, 112, 2, 2, 408, 409, 7, 117, 2, 2, 409, 410, 7, 97, 2, 2,
410, 411, 7, 99, 2, 2, 411, 412, 7, 110, 2, 2, 412, 432, 7, 110, 2, 2,
413, 414, 7, 67, 2, 2, 414, 415, 7, 84, 2, 2, 415, 416, 7, 84, 2, 2, 416,
417, 7, 67, 2, 2, 417, 418, 7, 91, 2, 2, 418, 419, 7, 97, 2, 2, 419, 420,
7, 69, 2, 2, 420, 421, 7, 81, 2, 2, 421, 422, 7, 80, 2, 2, 422, 423, 7,
86, 2, 2, 423, 424, 7, 67, 2, 2, 424, 425, 7, 75, 2, 2, 425, 426, 7, 80,
2, 2, 426, 427, 7, 85, 2, 2, 427, 428, 7, 97, 2, 2, 428, 429, 7, 67, 2,
2, 429, 430, 7, 78, 2, 2, 430, 432, 7, 78, 2, 2, 431, 395, 3, 2, 2, 2,
431, 413, 3, 2, 2, 2, 432, 76, 3, 2, 2, 2, 433, 434, 7, 99, 2, 2, 434,
435, 7, 116, 2, 2, 435, 436, 7, 116, 2, 2, 436, 437, 7, 99, 2, 2, 437,
438, 7, 123, 2, 2, 438, 439, 7, 97, 2, 2, 439, 440, 7, 101, 2, 2, 440,
441, 7, 113, 2, 2, 441, 442, 7, 112, 2, 2, 442, 443, 7, 118, 2, 2, 443,
444, 7, 99, 2, 2, 444, 445, 7, 107, 2, 2, 445, 446, 7, 112, 2, 2, 446,
447, 7, 117, 2, 2, 447, 448, 7, 97, 2, 2, 448, 449, 7, 99, 2, 2, 449, 450,
7, 112, 2, 2, 450, 470, 7, 123, 2, 2, 451, 452, 7, 67, 2, 2, 452, 453,
7, 84, 2, 2, 453, 454, 7, 84, 2, 2, 454, 455, 7, 67, 2, 2, 455, 456, 7,
91, 2, 2, 456, 457, 7, 97, 2, 2, 457, 458, 7, 69, 2, 2, 458, 459, 7, 81,
2, 2, 459, 460, 7, 80, 2, 2, 460, 461, 7, 86, 2, 2, 461, 462, 7, 67, 2,
2, 462, 463, 7, 75, 2, 2, 463, 464, 7, 80, 2, 2, 464, 465, 7, 85, 2, 2,
465, 466, 7, 97, 2, 2, 466, 467, 7, 67, 2, 2, 467, 468, 7, 80, 2, 2, 468,
470, 7, 91, 2, 2, 469, 433, 3, 2, 2, 2, 469, 451, 3, 2, 2, 2, 470, 78,
3, 2, 2, 2, 471, 472, 7, 99, 2, 2, 472, 473, 7, 116, 2, 2, 473, 474, 7,
116, 2, 2, 474, 475, 7, 99, 2, 2, 475, 476, 7, 123, 2, 2, 476, 477, 7,
97, 2, 2, 477, 478, 7, 110, 2, 2, 478, 479, 7, 103, 2, 2, 479, 480, 7,
112, 2, 2, 480, 481, 7, 105, 2, 2, 481, 482, 7, 118, 2, 2, 482, 496, 7,
106, 2, 2, 483, 484, 7, 67, 2, 2, 484, 485, 7, 84, 2, 2, 485, 486, 7, 84,
2, 2, 486, 487, 7, 67, 2, 2, 487, 488, 7, 91, 2, 2, 488, 489, 7, 97, 2,
2, 489, 490, 7, 78, 2, 2, 490, 491, 7, 71, 2, 2, 491, 492, 7, 80, 2, 2,
492, 493, 7, 73, 2, 2, 493, 494, 7, 86, 2, 2, 494, 496, 7, 74, 2, 2, 495,
471, 3, 2, 2, 2, 495, 483, 3, 2, 2, 2, 496, 80, 3, 2, 2, 2, 497, 498, 7,
118, 2, 2, 498, 499, 7, 116, 2, 2, 499, 500, 7, 119, 2, 2, 500, 525, 7,
103, 2, 2, 501, 502, 7, 86, 2, 2, 502, 503, 7, 116, 2, 2, 503, 504, 7,
119, 2, 2, 504, 525, 7, 103, 2, 2, 505, 506, 7, 86, 2, 2, 506, 507, 7,
84, 2, 2, 507, 508, 7, 87, 2, 2, 508, 525, 7, 71, 2, 2, 509, 510, 7, 104,
2, 2, 510, 511, 7, 99, 2, 2, 511, 512, 7, 110, 2, 2, 512, 513, 7, 117,
2, 2, 513, 525, 7, 103, 2, 2, 514, 515, 7, 72, 2, 2, 515, 516, 7, 99, 2,
2, 516, 517, 7, 110, 2, 2, 517, 518, 7, 117, 2, 2, 518, 525, 7, 103, 2,
2, 519, 520, 7, 72, 2, 2, 520, 521, 7, 67, 2, 2, 521, 522, 7, 78, 2, 2,
522, 523, 7, 85, 2, 2, 523, 525, 7, 71, 2, 2, 524, 497, 3, 2, 2, 2, 524,
501, 3, 2, 2, 2, 524, 505, 3, 2, 2, 2, 524, 509, 3, 2, 2, 2, 524, 514,
3, 2, 2, 2, 524, 519, 3, 2, 2, 2, 525, 82, 3, 2, 2, 2, 526, 531, 5, 111,
56, 2, 527, 531, 5, 113, 57, 2, 528, 531, 5, 115, 58, 2, 529, 531, 5, 109,
55, 2, 530, 526, 3, 2, 2, 2, 530, 527, 3, 2, 2, 2, 530, 528, 3, 2, 2, 2,
530, 529, 3, 2, 2, 2, 531, 84, 3, 2, 2, 2, 532, 535, 5, 127, 64, 2, 533,
535, 5, 129, 65, 2, 534, 532, 3, 2, 2, 2, 534, 533, 3, 2, 2, 2, 535, 86,
3, 2, 2, 2, 536, 541, 5, 105, 53, 2, 537, 540, 5, 105, 53, 2, 538, 540,
5, 107, 54, 2, 539, 537, 3, 2, 2, 2, 539, 538, 3, 2, 2, 2, 540, 543, 3,
2, 2, 2, 541, 539, 3, 2, 2, 2, 541, 542, 3, 2, 2, 2, 542, 88, 3, 2, 2,
2, 543, 541, 3, 2, 2, 2, 544, 545, 7, 38, 2, 2, 545, 546, 7, 111, 2, 2,
546, 547, 7, 103, 2, 2, 547, 548, 7, 118, 2, 2, 548, 549, 7, 99, 2, 2,
549, 90, 3, 2, 2, 2, 550, 552, 5, 95, 48, 2, 551, 550, 3, 2, 2, 2, 551,
552, 3, 2, 2, 2, 552, 563, 3, 2, 2, 2, 553, 555, 7, 36, 2, 2, 554, 556,
5, 97, 49, 2, 555, 554, 3, 2, 2, 2, 555, 556, 3, 2, 2, 2, 556, 557, 3,
2, 2, 2, 557, 564, 7, 36, 2, 2, 558, 560, 7, 41, 2, 2, 559, 561, 5, 99,
50, 2, 560, 559, 3, 2, 2, 2, 560, 561, 3, 2, 2, 2, 561, 562, 3, 2, 2, 2,
562, 564, 7, 41, 2, 2, 563, 553, 3, 2, 2, 2, 563, 558, 3, 2, 2, 2, 564,
92, 3, 2, 2, 2, 565, 568, 5, 87, 44, 2, 566, 568, 5, 89, 45, 2, 567, 565,
3, 2, 2, 2, 567, 566, 3, 2, 2, 2, 568, 576, 3, 2, 2, 2, 569, 572, 7, 93,
2, 2, 570, 573, 5, 91, 46, 2, 571, 573, 5, 111, 56, 2, 572, 570, 3, 2,
2, 2, 572, 571, 3, 2, 2, 2, 573, 574, 3, 2, 2, 2, 574, 575, 7, 95, 2, 2,
575, 577, 3, 2, 2, 2, 576, 569, 3, 2, 2, 2, 577, 578, 3, 2, 2, 2, 578,
576, 3, 2, 2, 2, 578, 579, 3, 2, 2, 2, 579, 94, 3, 2, 2, 2, 580, 581, 7,
119, 2, 2, 581, 584, 7, 58, 2, 2, 582, 584, 9, 2, 2, 2, 583, 580, 3, 2,
2, 2, 583, 582, 3, 2, 2, 2, 584, 96, 3, 2, 2, 2, 585, 587, 5, 101, 51,
2, 586, 585, 3, 2, 2, 2, 587, 588, 3, 2, 2, 2, 588, 586, 3, 2, 2, 2, 588,
589, 3, 2, 2, 2, 589, 98, 3, 2, 2, 2, 590, 592, 5, 103, 52, 2, 591, 590,
3, 2, 2, 2, 592, 593, 3, 2, 2, 2, 593, 591, 3, 2, 2, 2, 593, 594, 3, 2,
2, 2, 594, 100, 3, 2, 2, 2, 595, 603, 10, 3, 2, 2, 596, 603, 5, 143, 72,
2, 597, 598, 7, 94, 2, 2, 598, 603, 7, 12, 2, 2, 599, 600, 7, 94, 2, 2,
600, 601, 7, 15, 2, 2, 601, 603, 7, 12, 2, 2, 602, 595, 3, 2, 2, 2, 602,
596, 3, 2, 2, 2, 602, 597, 3, 2, 2, 2, 602, 599, 3, 2, 2, 2, 603, 102,
3, 2, 2, 2, 604, 612, 10, 4, 2, 2, 605, 612, 5, 143, 72, 2, 606, 607, 7,
94, 2, 2, 607, 612, 7, 12, 2, 2, 608, 609, 7, 94, 2, 2, 609, 610, 7, 15,
2, 2, 610, 612, 7, 12, 2, 2, 611, 604, 3, 2, 2, 2, 611, 605, 3, 2, 2, 2,
611, 606, 3, 2, 2, 2, 611, 608, 3, 2, 2, 2, 612, 104, 3, 2, 2, 2, 613,
614, 9, 5, 2, 2, 614, 106, 3, 2, 2, 2, 615, 616, 9, 6, 2, 2, 616, 108,
3, 2, 2, 2, 617, 618, 7, 50, 2, 2, 618, 620, 9, 7, 2, 2, 619, 621, 9, 8,
2, 2, 620, 619, 3, 2, 2, 2, 621, 622, 3, 2, 2, 2, 622, 620, 3, 2, 2, 2,
622, 623, 3, 2, 2, 2, 623, 110, 3, 2, 2, 2, 624, 628, 5, 117, 59, 2, 625,
627, 5, 107, 54, 2, 626, 625, 3, 2, 2, 2, 627, 630, 3, 2, 2, 2, 628, 626,
3, 2, 2, 2, 628, 629, 3, 2, 2, 2, 629, 633, 3, 2, 2, 2, 630, 628, 3, 2,
2, 2, 631, 633, 7, 50, 2, 2, 632, 624, 3, 2, 2, 2, 632, 631, 3, 2, 2, 2,
633, 112, 3, 2, 2, 2, 634, 638, 7, 50, 2, 2, 635, 637, 5, 119, 60, 2, 636,
635, 3, 2, 2, 2, 637, 640, 3, 2, 2, 2, 638, 636, 3, 2, 2, 2, 638, 639,
3, 2, 2, 2, 639, 114, 3, 2, 2, 2, 640, 638, 3, 2, 2, 2, 641, 642, 7, 50,
2, 2, 642, 643, 9, 9, 2, 2, 643, 644, 5, 139, 70, 2, 644, 116, 3, 2, 2,
2, 645, 646, 9, 10, 2, 2, 646, 118, 3, 2, 2, 2, 647, 648, 9, 11, 2, 2,
648, 120, 3, 2, 2, 2, 649, 650, 9, 12, 2, 2, 650, 122, 3, 2, 2, 2, 651,
652, 5, 121, 61, 2, 652, 653, 5, 121, 61, 2, 653, 654, 5, 121, 61, 2, 654,
655, 5, 121, 61, 2, 655, 124, 3, 2, 2, 2, 656, 657, 7, 94, 2, 2, 657, 658,
7, 119, 2, 2, 658, 659, 3, 2, 2, 2, 659, 667, 5, 123, 62, 2, 660, 661,
7, 94, 2, 2, 661, 662, 7, 87, 2, 2, 662, 663, 3, 2, 2, 2, 663, 664, 5,
123, 62, 2, 664, 665, 5, 123, 62, 2, 665, 667, 3, 2, 2, 2, 666, 656, 3,
2, 2, 2, 666, 660, 3, 2, 2, 2, 667, 126, 3, 2, 2, 2, 668, 670, 5, 131,
66, 2, 669, 671, 5, 133, 67, 2, 670, 669, 3, 2, 2, 2, 670, 671, 3, 2, 2,
2, 671, 676, 3, 2, 2, 2, 672, 673, 5, 135, 68, 2, 673, 674, 5, 133, 67,
2, 674, 676, 3, 2, 2, 2, 675, 668, 3, 2, 2, 2, 675, 672, 3, 2, 2, 2, 676,
128, 3, 2, 2, 2, 677, 678, 7, 50, 2, 2, 678, 681, 9, 9, 2, 2, 679, 682,
5, 137, 69, 2, 680, 682, 5, 139, 70, 2, 681, 679, 3, 2, 2, 2, 681, 680,
3, 2, 2, 2, 682, 683, 3, 2, 2, 2, 683, 684, 5, 141, 71, 2, 684, 130, 3,
2, 2, 2, 685, 687, 5, 135, 68, 2, 686, 685, 3, 2, 2, 2, 686, 687, 3, 2,
2, 2, 687, 688, 3, 2, 2, 2, 688, 689, 7, 48, 2, 2, 689, 694, 5, 135, 68,
2, 690, 691, 5, 135, 68, 2, 691, 692, 7, 48, 2, 2, 692, 694, 3, 2, 2, 2,
693, 686, 3, 2, 2, 2, 693, 690, 3, 2, 2, 2, 694, 132, 3, 2, 2, 2, 695,
697, 9, 13, 2, 2, 696, 698, 9, 14, 2, 2, 697, 696, 3, 2, 2, 2, 697, 698,
3, 2, 2, 2, 698, 699, 3, 2, 2, 2, 699, 700, 5, 135, 68, 2, 700, 134, 3,
2, 2, 2, 701, 703, 5, 107, 54, 2, 702, 701, 3, 2, 2, 2, 703, 704, 3, 2,
2, 2, 704, 702, 3, 2, 2, 2, 704, 705, 3, 2, 2, 2, 705, 136, 3, 2, 2, 2,
706, 708, 5, 139, 70, 2, 707, 706, 3, 2, 2, 2, 707, 708, 3, 2, 2, 2, 708,
709, 3, 2, 2, 2, 709, 710, 7, 48, 2, 2, 710, 715, 5, 139, 70, 2, 711, 712,
5, 139, 70, 2, 712, 713, 7, 48, 2, 2, 713, 715, 3, 2, 2, 2, 714, 707, 3,
2, 2, 2, 714, 711, 3, 2, 2, 2, 715, 138, 3, 2, 2, 2, 716, 718, 5, 121,
61, 2, 717, 716, 3, 2, 2, 2, 718, 719, 3, 2, 2, 2, 719, 717, 3, 2, 2, 2,
719, 720, 3, 2, 2, 2, 720, 140, 3, 2, 2, 2, 721, 723, 9, 15, 2, 2, 722,
724, 9, 14, 2, 2, 723, 722, 3, 2, 2, 2, 723, 724, 3, 2, 2, 2, 724, 725,
3, 2, 2, 2, 725, 726, 5, 135, 68, 2, 726, 142, 3, 2, 2, 2, 727, 728, 7,
94, 2, 2, 728, 743, 9, 16, 2, 2, 729, 730, 7, 94, 2, 2, 730, 732, 5, 119,
60, 2, 731, 733, 5, 119, 60, 2, 732, 731, 3, 2, 2, 2, 732, 733, 3, 2, 2,
2, 733, 735, 3, 2, 2, 2, 734, 736, 5, 119, 60, 2, 735, 734, 3, 2, 2, 2,
735, 736, 3, 2, 2, 2, 736, 743, 3, 2, 2, 2, 737, 738, 7, 94, 2, 2, 738,
739, 7, 122, 2, 2, 739, 740, 3, 2, 2, 2, 740, 743, 5, 139, 70, 2, 741,
743, 5, 125, 63, 2, 742, 727, 3, 2, 2, 2, 742, 729, 3, 2, 2, 2, 742, 737,
3, 2, 2, 2, 742, 741, 3, 2, 2, 2, 743, 144, 3, 2, 2, 2, 744, 746, 9, 17,
2, 2, 745, 744, 3, 2, 2, 2, 746, 747, 3, 2, 2, 2, 747, 745, 3, 2, 2, 2,
747, 748, 3, 2, 2, 2, 748, 749, 3, 2, 2, 2, 749, 750, 8, 73, 2, 2, 750,
146, 3, 2, 2, 2, 751, 753, 7, 15, 2, 2, 752, 754, 7, 12, 2, 2, 753, 752,
3, 2, 2, 2, 753, 754, 3, 2, 2, 2, 754, 757, 3, 2, 2, 2, 755, 757, 7, 12,
2, 2, 756, 751, 3, 2, 2, 2, 756, 755, 3, 2, 2, 2, 757, 758, 3, 2, 2, 2,
758, 759, 8, 74, 2, 2, 759, 148, 3, 2, 2, 2, 57, 2, 187, 201, 233, 239,
247, 253, 258, 260, 291, 327, 363, 393, 431, 469, 495, 524, 530, 534, 539,
541, 551, 555, 560, 563, 567, 572, 578, 583, 588, 593, 602, 611, 622, 628,
632, 638, 666, 670, 675, 681, 686, 693, 697, 704, 707, 714, 719, 723, 732,
735, 742, 747, 753, 756, 3, 8, 2, 2,
}
var lexerChannelNames = []string{
@ -368,35 +371,36 @@ var lexerModeNames = []string{
}
var lexerLiteralNames = []string{
"", "'('", "')'", "'['", "','", "']'", "'<'", "'<='", "'>'", "'>='", "'=='",
"'!='", "", "", "'+'", "'-'", "'*'", "'/'", "'%'", "'**'", "'<<'", "'>>'",
"'&'", "'|'", "'^'", "", "", "'~'", "", "'in'", "'not in'",
"", "'('", "')'", "'['", "','", "']'", "'{'", "'}'", "'<'", "'<='", "'>'",
"'>='", "'=='", "'!='", "", "", "'+'", "'-'", "'*'", "'/'", "'%'", "'**'",
"'<<'", "'>>'", "'&'", "'|'", "'^'", "", "", "'~'", "", "", "", "", "",
"", "", "", "", "", "", "", "", "", "'$meta'",
}
var lexerSymbolicNames = []string{
"", "", "", "", "", "", "LT", "LE", "GT", "GE", "EQ", "NE", "LIKE", "EXISTS",
"ADD", "SUB", "MUL", "DIV", "MOD", "POW", "SHL", "SHR", "BAND", "BOR",
"BXOR", "AND", "OR", "BNOT", "NOT", "IN", "NIN", "EmptyTerm", "JSONContains",
"JSONContainsAll", "JSONContainsAny", "ArrayContains", "ArrayContainsAll",
"ArrayContainsAny", "ArrayLength", "BooleanConstant", "IntegerConstant",
"FloatingConstant", "Identifier", "StringLiteral", "JSONIdentifier", "Whitespace",
"Newline",
"", "", "", "", "", "", "LBRACE", "RBRACE", "LT", "LE", "GT", "GE", "EQ",
"NE", "LIKE", "EXISTS", "ADD", "SUB", "MUL", "DIV", "MOD", "POW", "SHL",
"SHR", "BAND", "BOR", "BXOR", "AND", "OR", "BNOT", "NOT", "IN", "EmptyArray",
"JSONContains", "JSONContainsAll", "JSONContainsAny", "ArrayContains",
"ArrayContainsAll", "ArrayContainsAny", "ArrayLength", "BooleanConstant",
"IntegerConstant", "FloatingConstant", "Identifier", "Meta", "StringLiteral",
"JSONIdentifier", "Whitespace", "Newline",
}
var lexerRuleNames = []string{
"T__0", "T__1", "T__2", "T__3", "T__4", "LT", "LE", "GT", "GE", "EQ", "NE",
"LIKE", "EXISTS", "ADD", "SUB", "MUL", "DIV", "MOD", "POW", "SHL", "SHR",
"BAND", "BOR", "BXOR", "AND", "OR", "BNOT", "NOT", "IN", "NIN", "EmptyTerm",
"JSONContains", "JSONContainsAll", "JSONContainsAny", "ArrayContains",
"ArrayContainsAll", "ArrayContainsAny", "ArrayLength", "BooleanConstant",
"IntegerConstant", "FloatingConstant", "Identifier", "StringLiteral", "JSONIdentifier",
"EncodingPrefix", "DoubleSCharSequence", "SingleSCharSequence", "DoubleSChar",
"SingleSChar", "Nondigit", "Digit", "BinaryConstant", "DecimalConstant",
"OctalConstant", "HexadecimalConstant", "NonzeroDigit", "OctalDigit", "HexadecimalDigit",
"HexQuad", "UniversalCharacterName", "DecimalFloatingConstant", "HexadecimalFloatingConstant",
"FractionalConstant", "ExponentPart", "DigitSequence", "HexadecimalFractionalConstant",
"HexadecimalDigitSequence", "BinaryExponentPart", "EscapeSequence", "Whitespace",
"Newline",
"T__0", "T__1", "T__2", "T__3", "T__4", "LBRACE", "RBRACE", "LT", "LE",
"GT", "GE", "EQ", "NE", "LIKE", "EXISTS", "ADD", "SUB", "MUL", "DIV", "MOD",
"POW", "SHL", "SHR", "BAND", "BOR", "BXOR", "AND", "OR", "BNOT", "NOT",
"IN", "EmptyArray", "JSONContains", "JSONContainsAll", "JSONContainsAny",
"ArrayContains", "ArrayContainsAll", "ArrayContainsAny", "ArrayLength",
"BooleanConstant", "IntegerConstant", "FloatingConstant", "Identifier",
"Meta", "StringLiteral", "JSONIdentifier", "EncodingPrefix", "DoubleSCharSequence",
"SingleSCharSequence", "DoubleSChar", "SingleSChar", "Nondigit", "Digit",
"BinaryConstant", "DecimalConstant", "OctalConstant", "HexadecimalConstant",
"NonzeroDigit", "OctalDigit", "HexadecimalDigit", "HexQuad", "UniversalCharacterName",
"DecimalFloatingConstant", "HexadecimalFloatingConstant", "FractionalConstant",
"ExponentPart", "DigitSequence", "HexadecimalFractionalConstant", "HexadecimalDigitSequence",
"BinaryExponentPart", "EscapeSequence", "Whitespace", "Newline",
}
type PlanLexer struct {
@ -441,45 +445,47 @@ const (
PlanLexerT__2 = 3
PlanLexerT__3 = 4
PlanLexerT__4 = 5
PlanLexerLT = 6
PlanLexerLE = 7
PlanLexerGT = 8
PlanLexerGE = 9
PlanLexerEQ = 10
PlanLexerNE = 11
PlanLexerLIKE = 12
PlanLexerEXISTS = 13
PlanLexerADD = 14
PlanLexerSUB = 15
PlanLexerMUL = 16
PlanLexerDIV = 17
PlanLexerMOD = 18
PlanLexerPOW = 19
PlanLexerSHL = 20
PlanLexerSHR = 21
PlanLexerBAND = 22
PlanLexerBOR = 23
PlanLexerBXOR = 24
PlanLexerAND = 25
PlanLexerOR = 26
PlanLexerBNOT = 27
PlanLexerNOT = 28
PlanLexerIN = 29
PlanLexerNIN = 30
PlanLexerEmptyTerm = 31
PlanLexerJSONContains = 32
PlanLexerJSONContainsAll = 33
PlanLexerJSONContainsAny = 34
PlanLexerArrayContains = 35
PlanLexerArrayContainsAll = 36
PlanLexerArrayContainsAny = 37
PlanLexerArrayLength = 38
PlanLexerBooleanConstant = 39
PlanLexerIntegerConstant = 40
PlanLexerFloatingConstant = 41
PlanLexerIdentifier = 42
PlanLexerStringLiteral = 43
PlanLexerJSONIdentifier = 44
PlanLexerWhitespace = 45
PlanLexerNewline = 46
PlanLexerLBRACE = 6
PlanLexerRBRACE = 7
PlanLexerLT = 8
PlanLexerLE = 9
PlanLexerGT = 10
PlanLexerGE = 11
PlanLexerEQ = 12
PlanLexerNE = 13
PlanLexerLIKE = 14
PlanLexerEXISTS = 15
PlanLexerADD = 16
PlanLexerSUB = 17
PlanLexerMUL = 18
PlanLexerDIV = 19
PlanLexerMOD = 20
PlanLexerPOW = 21
PlanLexerSHL = 22
PlanLexerSHR = 23
PlanLexerBAND = 24
PlanLexerBOR = 25
PlanLexerBXOR = 26
PlanLexerAND = 27
PlanLexerOR = 28
PlanLexerBNOT = 29
PlanLexerNOT = 30
PlanLexerIN = 31
PlanLexerEmptyArray = 32
PlanLexerJSONContains = 33
PlanLexerJSONContainsAll = 34
PlanLexerJSONContainsAny = 35
PlanLexerArrayContains = 36
PlanLexerArrayContainsAll = 37
PlanLexerArrayContainsAny = 38
PlanLexerArrayLength = 39
PlanLexerBooleanConstant = 40
PlanLexerIntegerConstant = 41
PlanLexerFloatingConstant = 42
PlanLexerIdentifier = 43
PlanLexerMeta = 44
PlanLexerStringLiteral = 45
PlanLexerJSONIdentifier = 46
PlanLexerWhitespace = 47
PlanLexerNewline = 48
)

825
internal/parser/planparserv2/generated/plan_parser.go
View File

File diff suppressed because it is too large Load Diff

9
internal/parser/planparserv2/generated/plan_visitor.go
View File

@ -37,6 +37,9 @@ type PlanVisitor interface {
// Visit a parse tree produced by PlanParser#LogicalAnd.
VisitLogicalAnd(ctx *LogicalAndContext) interface{}
// Visit a parse tree produced by PlanParser#TemplateVariable.
VisitTemplateVariable(ctx *TemplateVariableContext) interface{}
// Visit a parse tree produced by PlanParser#Equality.
VisitEquality(ctx *EqualityContext) interface{}
@ -52,6 +55,9 @@ type PlanVisitor interface {
// Visit a parse tree produced by PlanParser#BitOr.
VisitBitOr(ctx *BitOrContext) interface{}
// Visit a parse tree produced by PlanParser#EmptyArray.
VisitEmptyArray(ctx *EmptyArrayContext) interface{}
// Visit a parse tree produced by PlanParser#AddSub.
VisitAddSub(ctx *AddSubContext) interface{}
@ -91,9 +97,6 @@ type PlanVisitor interface {
// Visit a parse tree produced by PlanParser#BitAnd.
VisitBitAnd(ctx *BitAndContext) interface{}
// Visit a parse tree produced by PlanParser#EmptyTerm.
VisitEmptyTerm(ctx *EmptyTermContext) interface{}
// Visit a parse tree produced by PlanParser#Power.
VisitPower(ctx *PowerContext) interface{}
}

12
internal/parser/planparserv2/node_ret.go
View File

@ -39,3 +39,15 @@ func getGenericValue(obj interface{}) *planpb.GenericValue {
}
return expr.expr.GetValueExpr().GetValue()
}
func getValueExpr(obj interface{}) *planpb.ValueExpr {
expr := getExpr(obj)
if expr == nil {
return nil
}
return expr.expr.GetValueExpr()
}
func isTemplateExpr(expr *planpb.ValueExpr) bool {
return expr != nil && expr.GetTemplateVariableName() != ""
}

549
internal/parser/planparserv2/parser_visitor.go
View File

@ -61,7 +61,7 @@ func (v *ParserVisitor) translateIdentifier(identifier string) (*ExprWithType, e
// VisitIdentifier translates expr to column plan.
func (v *ParserVisitor) VisitIdentifier(ctx *parser.IdentifierContext) interface{} {
identifier := ctx.Identifier().GetText()
identifier := ctx.GetText()
expr, err := v.translateIdentifier(identifier)
if err != nil {
return err
@ -157,18 +157,23 @@ func checkDirectComparisonBinaryField(columnInfo *planpb.ColumnInfo) error {
// VisitAddSub translates expr to arithmetic plan.
func (v *ParserVisitor) VisitAddSub(ctx *parser.AddSubContext) interface{} {
var err error
left := ctx.Expr(0).Accept(v)
if err := getError(left); err != nil {
if err = getError(left); err != nil {
return err
}
right := ctx.Expr(1).Accept(v)
if err := getError(right); err != nil {
if err = getError(right); err != nil {
return err
}
leftValue, rightValue := getGenericValue(left), getGenericValue(right)
if leftValue != nil && rightValue != nil {
leftValueExpr, rightValueExpr := getValueExpr(left), getValueExpr(right)
if leftValueExpr != nil && rightValueExpr != nil {
if isTemplateExpr(leftValueExpr) || isTemplateExpr(rightValueExpr) {
return fmt.Errorf("placeholder was not supported between two constants with operator: %s", ctx.GetOp().GetText())
}
leftValue, rightValue := leftValueExpr.GetValue(), rightValueExpr.GetValue()
switch ctx.GetOp().GetTokenType() {
case parser.PlanParserADD:
return Add(leftValue, rightValue)
@ -179,34 +184,37 @@ func (v *ParserVisitor) VisitAddSub(ctx *parser.AddSubContext) interface{} {
}
}
var leftExpr *ExprWithType
var rightExpr *ExprWithType
leftExpr, rightExpr := getExpr(left), getExpr(right)
reverse := true
if leftValue != nil {
leftExpr = toValueExpr(leftValue)
} else {
if leftValueExpr == nil {
reverse = false
leftExpr = getExpr(left)
}
if rightValue != nil {
rightExpr = toValueExpr(rightValue)
} else {
rightExpr = getExpr(right)
}
if leftExpr == nil || rightExpr == nil {
return fmt.Errorf("invalid arithmetic expression, left: %s, op: %s, right: %s", ctx.Expr(0).GetText(), ctx.GetOp(), ctx.Expr(1).GetText())
}
if err := checkDirectComparisonBinaryField(toColumnInfo(leftExpr)); err != nil {
if err = checkDirectComparisonBinaryField(toColumnInfo(leftExpr)); err != nil {
return err
}
if err := checkDirectComparisonBinaryField(toColumnInfo(rightExpr)); err != nil {
if err = checkDirectComparisonBinaryField(toColumnInfo(rightExpr)); err != nil {
return err
}
if !canArithmetic(leftExpr, rightExpr) {
return fmt.Errorf("'%s' can only be used between integer or floating or json field expressions", arithNameMap[ctx.GetOp().GetTokenType()])
var dataType schemapb.DataType
if leftExpr.expr.GetIsTemplate() {
dataType = rightExpr.dataType
} else if rightExpr.expr.GetIsTemplate() {
dataType = leftExpr.dataType
} else {
if !canArithmetic(leftExpr.dataType, getArrayElementType(leftExpr), rightExpr.dataType, getArrayElementType(rightExpr)) {
return fmt.Errorf("'%s' can only be used between integer or floating or json field expressions", arithNameMap[ctx.GetOp().GetTokenType()])
}
dataType, err = calcDataType(leftExpr, rightExpr, reverse)
if err != nil {
return err
}
}
expr := &planpb.Expr{
@ -217,10 +225,7 @@ func (v *ParserVisitor) VisitAddSub(ctx *parser.AddSubContext) interface{} {
Op: arithExprMap[ctx.GetOp().GetTokenType()],
},
},
}
dataType, err := calcDataType(leftExpr, rightExpr, reverse)
if err != nil {
return err
IsTemplate: leftExpr.expr.GetIsTemplate() || rightExpr.expr.GetIsTemplate(),
}
return &ExprWithType{
expr: expr,
@ -231,6 +236,7 @@ func (v *ParserVisitor) VisitAddSub(ctx *parser.AddSubContext) interface{} {
// VisitMulDivMod translates expr to arithmetic plan.
func (v *ParserVisitor) VisitMulDivMod(ctx *parser.MulDivModContext) interface{} {
var err error
left := ctx.Expr(0).Accept(v)
if err := getError(left); err != nil {
return err
@ -241,8 +247,12 @@ func (v *ParserVisitor) VisitMulDivMod(ctx *parser.MulDivModContext) interface{}
return err
}
leftValue, rightValue := getGenericValue(left), getGenericValue(right)
if leftValue != nil && rightValue != nil {
leftValueExpr, rightValueExpr := getValueExpr(left), getValueExpr(right)
if leftValueExpr != nil && rightValueExpr != nil {
if isTemplateExpr(leftValueExpr) || isTemplateExpr(rightValueExpr) {
return fmt.Errorf("placeholder was not supported between two constants with operator: %s", ctx.GetOp().GetText())
}
leftValue, rightValue := getGenericValue(left), getGenericValue(right)
switch ctx.GetOp().GetTokenType() {
case parser.PlanParserMUL:
return Multiply(leftValue, rightValue)
@ -263,21 +273,12 @@ func (v *ParserVisitor) VisitMulDivMod(ctx *parser.MulDivModContext) interface{}
}
}
var leftExpr *ExprWithType
var rightExpr *ExprWithType
leftExpr, rightExpr := getExpr(left), getExpr(right)
reverse := true
if leftValue != nil {
leftExpr = toValueExpr(leftValue)
} else {
leftExpr = getExpr(left)
if leftValueExpr == nil {
reverse = false
}
if rightValue != nil {
rightExpr = toValueExpr(rightValue)
} else {
rightExpr = getExpr(right)
}
if leftExpr == nil || rightExpr == nil {
return fmt.Errorf("invalid arithmetic expression, left: %s, op: %s, right: %s", ctx.Expr(0).GetText(), ctx.GetOp(), ctx.Expr(1).GetText())
@ -289,18 +290,27 @@ func (v *ParserVisitor) VisitMulDivMod(ctx *parser.MulDivModContext) interface{}
if err := checkDirectComparisonBinaryField(toColumnInfo(rightExpr)); err != nil {
return err
}
if !canArithmetic(leftExpr, rightExpr) {
return fmt.Errorf("'%s' can only be used between integer or floating or json field expressions", arithNameMap[ctx.GetOp().GetTokenType()])
var dataType schemapb.DataType
if leftExpr.expr.GetIsTemplate() {
dataType = rightExpr.dataType
} else if rightExpr.expr.GetIsTemplate() {
dataType = leftExpr.dataType
} else {
if !canArithmetic(leftExpr.dataType, getArrayElementType(leftExpr), rightExpr.dataType, getArrayElementType(rightExpr)) {
return fmt.Errorf("'%s' can only be used between integer or floating or json field expressions", arithNameMap[ctx.GetOp().GetTokenType()])
}
if err = checkValidModArith(arithExprMap[ctx.GetOp().GetTokenType()], leftExpr.dataType, getArrayElementType(leftExpr), rightExpr.dataType, getArrayElementType(rightExpr)); err != nil {
return err
}
dataType, err = calcDataType(leftExpr, rightExpr, reverse)
if err != nil {
return err
}
}
switch ctx.GetOp().GetTokenType() {
case parser.PlanParserMOD:
if !isIntegerColumn(toColumnInfo(leftExpr)) && !isIntegerColumn(toColumnInfo(rightExpr)) {
return fmt.Errorf("modulo can only apply on integer types")
}
default:
break
}
expr := &planpb.Expr{
Expr: &planpb.Expr_BinaryArithExpr{
BinaryArithExpr: &planpb.BinaryArithExpr{
@ -309,11 +319,9 @@ func (v *ParserVisitor) VisitMulDivMod(ctx *parser.MulDivModContext) interface{}
Op: arithExprMap[ctx.GetOp().GetTokenType()],
},
},
IsTemplate: leftExpr.expr.GetIsTemplate() || rightExpr.expr.GetIsTemplate(),
}
dataType, err := calcDataType(leftExpr, rightExpr, reverse)
if err != nil {
return err
}
return &ExprWithType{
expr: expr,
dataType: dataType,
@ -333,8 +341,12 @@ func (v *ParserVisitor) VisitEquality(ctx *parser.EqualityContext) interface{} {
return err
}
leftValue, rightValue := getGenericValue(left), getGenericValue(right)
if leftValue != nil && rightValue != nil {
leftValueExpr, rightValueExpr := getValueExpr(left), getValueExpr(right)
if leftValueExpr != nil && rightValueExpr != nil {
if isTemplateExpr(leftValueExpr) || isTemplateExpr(rightValueExpr) {
return fmt.Errorf("placeholder was not supported between two constants with operator: %s", ctx.GetOp().GetText())
}
leftValue, rightValue := leftValueExpr.GetValue(), rightValueExpr.GetValue()
var ret *ExprWithType
switch ctx.GetOp().GetTokenType() {
case parser.PlanParserEQ:
@ -350,18 +362,7 @@ func (v *ParserVisitor) VisitEquality(ctx *parser.EqualityContext) interface{} {
return ret
}
var leftExpr *ExprWithType
var rightExpr *ExprWithType
if leftValue != nil {
leftExpr = toValueExpr(leftValue)
} else {
leftExpr = getExpr(left)
}
if rightValue != nil {
rightExpr = toValueExpr(rightValue)
} else {
rightExpr = getExpr(right)
}
leftExpr, rightExpr := getExpr(left), getExpr(right)
expr, err := HandleCompare(ctx.GetOp().GetTokenType(), leftExpr, rightExpr)
if err != nil {
@ -385,10 +386,12 @@ func (v *ParserVisitor) VisitRelational(ctx *parser.RelationalContext) interface
if err := getError(right); err != nil {
return err
}
leftValue, rightValue := getGenericValue(left), getGenericValue(right)
if leftValue != nil && rightValue != nil {
leftValueExpr, rightValueExpr := getValueExpr(left), getValueExpr(right)
if leftValueExpr != nil && rightValueExpr != nil {
if isTemplateExpr(leftValueExpr) || isTemplateExpr(rightValueExpr) {
return fmt.Errorf("placeholder was not supported between two constants with operator: %s", ctx.GetOp().GetText())
}
leftValue, rightValue := getGenericValue(left), getGenericValue(right)
var ret *ExprWithType
switch ctx.GetOp().GetTokenType() {
case parser.PlanParserLT:
@ -408,18 +411,7 @@ func (v *ParserVisitor) VisitRelational(ctx *parser.RelationalContext) interface
return ret
}
var leftExpr *ExprWithType
var rightExpr *ExprWithType
if leftValue != nil {
leftExpr = toValueExpr(leftValue)
} else {
leftExpr = getExpr(left)
}
if rightValue != nil {
rightExpr = toValueExpr(rightValue)
} else {
rightExpr = getExpr(right)
}
leftExpr, rightExpr := getExpr(left), getExpr(right)
if err := checkDirectComparisonBinaryField(toColumnInfo(leftExpr)); err != nil {
return err
}
@ -508,80 +500,50 @@ func (v *ParserVisitor) VisitTerm(ctx *parser.TermContext) interface{} {
if typeutil.IsArrayType(dataType) && len(columnInfo.GetNestedPath()) != 0 {
dataType = columnInfo.GetElementType()
}
allExpr := ctx.AllExpr()
lenOfAllExpr := len(allExpr)
values := make([]*planpb.GenericValue, 0, lenOfAllExpr)
for i := 1; i < lenOfAllExpr; i++ {
term := allExpr[i].Accept(v)
if getError(term) != nil {
return term
}
n := getGenericValue(term)
if n == nil {
return fmt.Errorf("value '%s' in list cannot be a non-const expression", ctx.Expr(i).GetText())
}
castedValue, err := castValue(dataType, n)
if err != nil {
return fmt.Errorf("value '%s' in list cannot be casted to %s", ctx.Expr(i).GetText(), dataType.String())
}
values = append(values, castedValue)
term := ctx.Expr(1).Accept(v)
if getError(term) != nil {
return term
}
if len(values) <= 0 {
return fmt.Errorf("'term' has empty value list")
valueExpr := getValueExpr(term)
var placeholder string
var neddFillPlaceholder bool
var values []*planpb.GenericValue
if valueExpr.GetValue() == nil && valueExpr.GetTemplateVariableName() != "" {
placeholder = valueExpr.GetTemplateVariableName()
values = nil
neddFillPlaceholder = true
} else {
elementValue := valueExpr.GetValue()
if elementValue == nil {
return fmt.Errorf(
"contains_any operation are only supported explicitly specified element, got: %s", ctx.Expr(1).GetText())
}
if !IsArray(elementValue) {
return fmt.Errorf("the right-hand side of 'in' must be a list, but got: %s", ctx.Expr(1).GetText())
}
array := elementValue.GetArrayVal().GetArray()
values = make([]*planpb.GenericValue, len(array))
for i, e := range array {
castedValue, err := castValue(dataType, e)
if err != nil {
return fmt.Errorf("value '%s' in list cannot be casted to %s", e.String(), dataType.String())
}
values[i] = castedValue
}
}
expr := &planpb.Expr{
Expr: &planpb.Expr_TermExpr{
TermExpr: &planpb.TermExpr{
ColumnInfo: columnInfo,
Values: values,
ColumnInfo: columnInfo,
Values: values,
TemplateVariableName: placeholder,
},
},
IsTemplate: neddFillPlaceholder,
}
if ctx.GetOp().GetTokenType() == parser.PlanParserNIN {
expr = &planpb.Expr{
Expr: &planpb.Expr_UnaryExpr{
UnaryExpr: &planpb.UnaryExpr{
Op: planpb.UnaryExpr_Not,
Child: expr,
},
},
}
}
return &ExprWithType{
expr: expr,
dataType: schemapb.DataType_Bool,
}
}
// VisitEmptyTerm translates expr to term plan.
func (v *ParserVisitor) VisitEmptyTerm(ctx *parser.EmptyTermContext) interface{} {
child := ctx.Expr().Accept(v)
if err := getError(child); err != nil {
return err
}
if childValue := getGenericValue(child); childValue != nil {
return fmt.Errorf("'term' can only be used on non-const expression, but got: %s", ctx.Expr().GetText())
}
childExpr := getExpr(child)
columnInfo := toColumnInfo(childExpr)
if columnInfo == nil {
return fmt.Errorf("'term' can only be used on single field, but got: %s", ctx.Expr().GetText())
}
if err := checkDirectComparisonBinaryField(columnInfo); err != nil {
return err
}
expr := &planpb.Expr{
Expr: &planpb.Expr_TermExpr{
TermExpr: &planpb.TermExpr{
ColumnInfo: columnInfo,
Values: nil,
},
},
}
if ctx.GetOp().GetTokenType() == parser.PlanParserNIN {
if ctx.GetOp() != nil {
expr = &planpb.Expr{
Expr: &planpb.Expr_UnaryExpr{
UnaryExpr: &planpb.UnaryExpr{
@ -589,6 +551,7 @@ func (v *ParserVisitor) VisitEmptyTerm(ctx *parser.EmptyTermContext) interface{}
Child: expr,
},
},
IsTemplate: neddFillPlaceholder,
}
}
return &ExprWithType{
@ -631,12 +594,11 @@ func (v *ParserVisitor) VisitRange(ctx *parser.RangeContext) interface{} {
return err
}
lowerValue := getGenericValue(lower)
upperValue := getGenericValue(upper)
if lowerValue == nil {
lowerValueExpr, upperValueExpr := getValueExpr(lower), getValueExpr(upper)
if lowerValueExpr == nil {
return fmt.Errorf("lowerbound cannot be a non-const expression: %s", ctx.Expr(0).GetText())
}
if upperValue == nil {
if upperValueExpr == nil {
return fmt.Errorf("upperbound cannot be a non-const expression: %s", ctx.Expr(1).GetText())
}
@ -645,52 +607,45 @@ func (v *ParserVisitor) VisitRange(ctx *parser.RangeContext) interface{} {
fieldDataType = columnInfo.GetElementType()
}
switch fieldDataType {
case schemapb.DataType_String, schemapb.DataType_VarChar:
if !IsString(lowerValue) || !IsString(upperValue) {
return fmt.Errorf("invalid range operations")
}
case schemapb.DataType_Bool:
return fmt.Errorf("invalid range operations on boolean expr")
case schemapb.DataType_Int8, schemapb.DataType_Int16, schemapb.DataType_Int32, schemapb.DataType_Int64:
if !IsInteger(lowerValue) || !IsInteger(upperValue) {
return fmt.Errorf("invalid range operations")
}
case schemapb.DataType_Float, schemapb.DataType_Double:
if !IsNumber(lowerValue) || !IsNumber(upperValue) {
return fmt.Errorf("invalid range operations")
}
if IsInteger(lowerValue) {
lowerValue = NewFloat(float64(lowerValue.GetInt64Val()))
}
if IsInteger(upperValue) {
upperValue = NewFloat(float64(upperValue.GetInt64Val()))
lowerValue := lowerValueExpr.GetValue()
upperValue := upperValueExpr.GetValue()
if !isTemplateExpr(lowerValueExpr) {
if err = checkRangeCompared(fieldDataType, lowerValue); err != nil {
return err
}
}
if !isTemplateExpr(upperValueExpr) {
if err = checkRangeCompared(fieldDataType, upperValue); err != nil {
return err
}
}
lowerInclusive := ctx.GetOp1().GetTokenType() == parser.PlanParserLE
upperInclusive := ctx.GetOp2().GetTokenType() == parser.PlanParserLE
// if !(lowerInclusive && upperInclusive) {
// if getGenericValue(GreaterEqual(lowerValue, upperValue)).GetBoolVal() {
// return fmt.Errorf("invalid range: lowerbound is greater than upperbound")
// }
// } else {
// if getGenericValue(Greater(lowerValue, upperValue)).GetBoolVal() {
// return fmt.Errorf("invalid range: lowerbound is greater than upperbound")
// }
// }
if !isTemplateExpr(lowerValueExpr) && !isTemplateExpr(upperValueExpr) {
if !(lowerInclusive && upperInclusive) {
if getGenericValue(GreaterEqual(lowerValue, upperValue)).GetBoolVal() {
return fmt.Errorf("invalid range: lowerbound is greater than upperbound")
}
} else {
if getGenericValue(Greater(lowerValue, upperValue)).GetBoolVal() {
return fmt.Errorf("invalid range: lowerbound is greater than upperbound")
}
}
}
expr := &planpb.Expr{
Expr: &planpb.Expr_BinaryRangeExpr{
BinaryRangeExpr: &planpb.BinaryRangeExpr{
ColumnInfo: columnInfo,
LowerInclusive: lowerInclusive,
UpperInclusive: upperInclusive,
LowerValue: lowerValue,
UpperValue: upperValue,
ColumnInfo: columnInfo,
LowerInclusive: lowerInclusive,
UpperInclusive: upperInclusive,
LowerValue: lowerValue,
UpperValue: upperValue,
LowerTemplateVariableName: lowerValueExpr.GetTemplateVariableName(),
UpperTemplateVariableName: upperValueExpr.GetTemplateVariableName(),
},
},
IsTemplate: isTemplateExpr(lowerValueExpr) || isTemplateExpr(upperValueExpr),
}
return &ExprWithType{
expr: expr,
@ -721,61 +676,58 @@ func (v *ParserVisitor) VisitReverseRange(ctx *parser.ReverseRangeContext) inter
return err
}
lowerValue := getGenericValue(lower)
upperValue := getGenericValue(upper)
if lowerValue == nil {
lowerValueExpr, upperValueExpr := getValueExpr(lower), getValueExpr(upper)
if lowerValueExpr == nil {
return fmt.Errorf("lowerbound cannot be a non-const expression: %s", ctx.Expr(0).GetText())
}
if upperValue == nil {
if upperValueExpr == nil {
return fmt.Errorf("upperbound cannot be a non-const expression: %s", ctx.Expr(1).GetText())
}
switch columnInfo.GetDataType() {
case schemapb.DataType_String, schemapb.DataType_VarChar:
if !IsString(lowerValue) || !IsString(upperValue) {
return fmt.Errorf("invalid range operations")
}
case schemapb.DataType_Bool:
return fmt.Errorf("invalid range operations on boolean expr")
case schemapb.DataType_Int8, schemapb.DataType_Int16, schemapb.DataType_Int32, schemapb.DataType_Int64:
if !IsInteger(lowerValue) || !IsInteger(upperValue) {
return fmt.Errorf("invalid range operations")
}
case schemapb.DataType_Float, schemapb.DataType_Double:
if !IsNumber(lowerValue) || !IsNumber(upperValue) {
return fmt.Errorf("invalid range operations")
}
if IsInteger(lowerValue) {
lowerValue = NewFloat(float64(lowerValue.GetInt64Val()))
}
if IsInteger(upperValue) {
upperValue = NewFloat(float64(upperValue.GetInt64Val()))
}
fieldDataType := columnInfo.GetDataType()
if typeutil.IsArrayType(columnInfo.GetDataType()) {
fieldDataType = columnInfo.GetElementType()
}
lowerValue := lowerValueExpr.GetValue()
upperValue := upperValueExpr.GetValue()
if !isTemplateExpr(lowerValueExpr) {
if err = checkRangeCompared(fieldDataType, lowerValue); err != nil {
return err
}
}
if !isTemplateExpr(upperValueExpr) {
if err = checkRangeCompared(fieldDataType, upperValue); err != nil {
return err
}
}
lowerInclusive := ctx.GetOp2().GetTokenType() == parser.PlanParserGE
upperInclusive := ctx.GetOp1().GetTokenType() == parser.PlanParserGE
// if !(lowerInclusive && upperInclusive) {
// if getGenericValue(GreaterEqual(lowerValue, upperValue)).GetBoolVal() {
// return fmt.Errorf("invalid range: lowerbound is greater than upperbound")
// }
// } else {
// if getGenericValue(Greater(lowerValue, upperValue)).GetBoolVal() {
// return fmt.Errorf("invalid range: lowerbound is greater than upperbound")
// }
// }
if !isTemplateExpr(lowerValueExpr) && !isTemplateExpr(upperValueExpr) {
if !(lowerInclusive && upperInclusive) {
if getGenericValue(GreaterEqual(lowerValue, upperValue)).GetBoolVal() {
return fmt.Errorf("invalid range: lowerbound is greater than upperbound")
}
} else {
if getGenericValue(Greater(lowerValue, upperValue)).GetBoolVal() {
return fmt.Errorf("invalid range: lowerbound is greater than upperbound")
}
}
}
expr := &planpb.Expr{
Expr: &planpb.Expr_BinaryRangeExpr{
BinaryRangeExpr: &planpb.BinaryRangeExpr{
ColumnInfo: columnInfo,
LowerInclusive: lowerInclusive,
UpperInclusive: upperInclusive,
LowerValue: lowerValue,
UpperValue: upperValue,
ColumnInfo: columnInfo,
LowerInclusive: lowerInclusive,
UpperInclusive: upperInclusive,
LowerValue: lowerValue,
UpperValue: upperValue,
LowerTemplateVariableName: lowerValueExpr.GetTemplateVariableName(),
UpperTemplateVariableName: upperValueExpr.GetTemplateVariableName(),
},
},
IsTemplate: isTemplateExpr(lowerValueExpr) || isTemplateExpr(upperValueExpr),
}
return &ExprWithType{
expr: expr,
@ -1106,7 +1058,7 @@ func (v *ParserVisitor) VisitExists(ctx *parser.ExistsContext) interface{} {
func (v *ParserVisitor) VisitArray(ctx *parser.ArrayContext) interface{} {
allExpr := ctx.AllExpr()
array := make([]*planpb.GenericValue, 0, len(allExpr))
array := make([]*planpb.GenericValue, len(allExpr))
dType := schemapb.DataType_None
sameType := true
for i := 0; i < len(allExpr); i++ {
@ -1118,7 +1070,7 @@ func (v *ParserVisitor) VisitArray(ctx *parser.ArrayContext) interface{} {
if elementValue == nil {
return fmt.Errorf("array element type must be generic value, but got: %s", allExpr[i].GetText())
}
array = append(array, elementValue)
array[i] = elementValue
if dType == schemapb.DataType_None {
dType = element.(*ExprWithType).dataType
@ -1151,6 +1103,28 @@ func (v *ParserVisitor) VisitArray(ctx *parser.ArrayContext) interface{} {
}
}
func (v *ParserVisitor) VisitEmptyArray(ctx *parser.EmptyArrayContext) interface{} {
return &ExprWithType{
dataType: schemapb.DataType_Array,
expr: &planpb.Expr{
Expr: &planpb.Expr_ValueExpr{
ValueExpr: &planpb.ValueExpr{
Value: &planpb.GenericValue{
Val: &planpb.GenericValue_ArrayVal{
ArrayVal: &planpb.Array{
Array: nil,
SameType: true,
ElementType: schemapb.DataType_None,
},
},
},
},
},
},
nodeDependent: true,
}
}
func (v *ParserVisitor) VisitJSONContains(ctx *parser.JSONContainsContext) interface{} {
field := ctx.Expr(0).Accept(v)
if err := getError(field); err != nil {
@ -1168,32 +1142,33 @@ func (v *ParserVisitor) VisitJSONContains(ctx *parser.JSONContainsContext) inter
if err := getError(element); err != nil {
return err
}
elementValue := getGenericValue(element)
if elementValue == nil {
elementExpr := getValueExpr(element)
if elementExpr == nil {
return fmt.Errorf(
"contains operation are only supported explicitly specified element, got: %s", ctx.Expr(1).GetText())
}
if typeutil.IsArrayType(columnInfo.GetDataType()) {
valExpr := toValueExpr(elementValue)
if !canBeCompared(field.(*ExprWithType), valExpr) {
return fmt.Errorf("contains operation can't compare between array element type: %s and %s",
columnInfo.GetElementType(),
valExpr.dataType)
}
}
var elements []*planpb.GenericValue
elements := make([]*planpb.GenericValue, 1)
elements[0] = elementValue
if !isTemplateExpr(elementExpr) {
elements = make([]*planpb.GenericValue, 1)
elementValue := elementExpr.GetValue()
if err := checkContainsElement(field.(*ExprWithType), planpb.JSONContainsExpr_Contains, elementValue); err != nil {
return err
}
elements[0] = elementValue
}
expr := &planpb.Expr{
Expr: &planpb.Expr_JsonContainsExpr{
JsonContainsExpr: &planpb.JSONContainsExpr{
ColumnInfo: columnInfo,
Elements: elements,
Op: planpb.JSONContainsExpr_Contains,
ElementsSameType: true,
ColumnInfo: columnInfo,
Elements: elements,
Op: planpb.JSONContainsExpr_Contains,
ElementsSameType: true,
TemplateVariableName: elementExpr.GetTemplateVariableName(),
},
},
IsTemplate: isTemplateExpr(elementExpr),
}
return &ExprWithType{
expr: expr,
@ -1218,36 +1193,35 @@ func (v *ParserVisitor) VisitJSONContainsAll(ctx *parser.JSONContainsAllContext)
if err := getError(element); err != nil {
return err
}
elementValue := getGenericValue(element)
if elementValue == nil {
elementExpr := getValueExpr(element)
if elementExpr == nil {
return fmt.Errorf(
"contains_all operation are only supported explicitly specified element, got: %s", ctx.Expr(1).GetText())
}
if elementValue.GetArrayVal() == nil {
return fmt.Errorf("contains_all operation element must be an array")
}
if typeutil.IsArrayType(columnInfo.GetDataType()) {
for _, value := range elementValue.GetArrayVal().GetArray() {
valExpr := toValueExpr(value)
if !canBeCompared(field.(*ExprWithType), valExpr) {
return fmt.Errorf("contains_all operation can't compare between array element type: %s and %s",
columnInfo.GetElementType(),
valExpr.dataType)
}
var elements []*planpb.GenericValue
var sameType bool
if !isTemplateExpr(elementExpr) {
elementValue := elementExpr.GetValue()
if err := checkContainsElement(field.(*ExprWithType), planpb.JSONContainsExpr_ContainsAll, elementValue); err != nil {
return err
}
elements = elementValue.GetArrayVal().GetArray()
sameType = elementValue.GetArrayVal().GetSameType()
}
expr := &planpb.Expr{
Expr: &planpb.Expr_JsonContainsExpr{
JsonContainsExpr: &planpb.JSONContainsExpr{
ColumnInfo: columnInfo,
Elements: elementValue.GetArrayVal().GetArray(),
Op: planpb.JSONContainsExpr_ContainsAll,
ElementsSameType: elementValue.GetArrayVal().GetSameType(),
ColumnInfo: columnInfo,
Elements: elements,
Op: planpb.JSONContainsExpr_ContainsAll,
ElementsSameType: sameType,
TemplateVariableName: elementExpr.GetTemplateVariableName(),
},
},
IsTemplate: isTemplateExpr(elementExpr),
}
return &ExprWithType{
expr: expr,
@ -1272,36 +1246,35 @@ func (v *ParserVisitor) VisitJSONContainsAny(ctx *parser.JSONContainsAnyContext)
if err := getError(element); err != nil {
return err
}
elementValue := getGenericValue(element)
if elementValue == nil {
valueExpr := getValueExpr(element)
if valueExpr == nil {
return fmt.Errorf(
"contains_any operation are only supported explicitly specified element, got: %s", ctx.Expr(1).GetText())
}
if elementValue.GetArrayVal() == nil {
return fmt.Errorf("contains_any operation element must be an array")
}
if typeutil.IsArrayType(columnInfo.GetDataType()) {
for _, value := range elementValue.GetArrayVal().GetArray() {
valExpr := toValueExpr(value)
if !canBeCompared(field.(*ExprWithType), valExpr) {
return fmt.Errorf("contains_any operation can't compare between array element type: %s and %s",
columnInfo.GetElementType(),
valExpr.dataType)
}
var elements []*planpb.GenericValue
var sameType bool
if !isTemplateExpr(valueExpr) {
elementValue := valueExpr.GetValue()
if err := checkContainsElement(field.(*ExprWithType), planpb.JSONContainsExpr_ContainsAny, elementValue); err != nil {
return err
}
elements = elementValue.GetArrayVal().GetArray()
sameType = elementValue.GetArrayVal().GetSameType()
}
expr := &planpb.Expr{
Expr: &planpb.Expr_JsonContainsExpr{
JsonContainsExpr: &planpb.JSONContainsExpr{
ColumnInfo: columnInfo,
Elements: elementValue.GetArrayVal().GetArray(),
Op: planpb.JSONContainsExpr_ContainsAny,
ElementsSameType: elementValue.GetArrayVal().GetSameType(),
ColumnInfo: columnInfo,
Elements: elements,
Op: planpb.JSONContainsExpr_ContainsAny,
ElementsSameType: sameType,
TemplateVariableName: valueExpr.GetTemplateVariableName(),
},
},
IsTemplate: isTemplateExpr(valueExpr),
}
return &ExprWithType{
expr: expr,
@ -1341,3 +1314,17 @@ func (v *ParserVisitor) VisitArrayLength(ctx *parser.ArrayLengthContext) interfa
nodeDependent: true,
}
}
func (v *ParserVisitor) VisitTemplateVariable(ctx *parser.TemplateVariableContext) interface{} {
return &ExprWithType{
expr: &planpb.Expr{
Expr: &planpb.Expr_ValueExpr{
ValueExpr: &planpb.ValueExpr{
Value: nil,
TemplateVariableName: ctx.Identifier().GetText(),
},
},
IsTemplate: true,
},
}
}

22
internal/parser/planparserv2/plan_parser_v2.go
View File

@ -17,6 +17,7 @@ import (
)
func handleExpr(schema *typeutil.SchemaHelper, exprStr string) interface{} {
exprStr = convertHanToASCII(exprStr)
return handleExprWithErrorListener(schema, exprStr, &errorListenerImpl{})
}
@ -57,7 +58,7 @@ func handleExprWithErrorListener(schema *typeutil.SchemaHelper, exprStr string,
return ast.Accept(visitor)
}
func ParseExpr(schema *typeutil.SchemaHelper, exprStr string) (*planpb.Expr, error) {
func ParseExpr(schema *typeutil.SchemaHelper, exprStr string, exprTemplateValues map[string]*schemapb.TemplateValue) (*planpb.Expr, error) {
ret := handleExpr(schema, exprStr)
if err := getError(ret); err != nil {
@ -72,6 +73,15 @@ func ParseExpr(schema *typeutil.SchemaHelper, exprStr string) (*planpb.Expr, err
return nil, fmt.Errorf("predicate is not a boolean expression: %s, data type: %s", exprStr, predicate.dataType)
}
valueMap, err := UnmarshalExpressionValues(exprTemplateValues)
if err != nil {
return nil, err
}
if err := FillExpressionValue(predicate.expr, valueMap); err != nil {
return nil, err
}
return predicate.expr, nil
}
@ -93,8 +103,8 @@ func ParseIdentifier(schema *typeutil.SchemaHelper, identifier string, checkFunc
return checkFunc(predicate.expr)
}
func CreateRetrievePlan(schema *typeutil.SchemaHelper, exprStr string) (*planpb.PlanNode, error) {
expr, err := ParseExpr(schema, exprStr)
func CreateRetrievePlan(schema *typeutil.SchemaHelper, exprStr string, exprTemplateValues map[string]*schemapb.TemplateValue) (*planpb.PlanNode, error) {
expr, err := ParseExpr(schema, exprStr, exprTemplateValues)
if err != nil {
return nil, err
}
@ -139,14 +149,12 @@ func convertHanToASCII(s string) string {
return builder.String()
}
func CreateSearchPlan(schema *typeutil.SchemaHelper, exprStr string, vectorFieldName string, queryInfo *planpb.QueryInfo) (*planpb.PlanNode, error) {
exprStr = convertHanToASCII(exprStr)
func CreateSearchPlan(schema *typeutil.SchemaHelper, exprStr string, vectorFieldName string, queryInfo *planpb.QueryInfo, exprTemplateValues map[string]*schemapb.TemplateValue) (*planpb.PlanNode, error) {
parse := func() (*planpb.Expr, error) {
if len(exprStr) <= 0 {
return nil, nil
}
return ParseExpr(schema, exprStr)
return ParseExpr(schema, exprStr, exprTemplateValues)
}
expr, err := parse()

91
internal/parser/planparserv2/plan_parser_v2_test.go
View File

@ -58,7 +58,7 @@ func newTestSchemaHelper(t *testing.T) *typeutil.SchemaHelper {
}
func assertValidExpr(t *testing.T, helper *typeutil.SchemaHelper, exprStr string) {
_, err := ParseExpr(helper, exprStr)
_, err := ParseExpr(helper, exprStr, nil)
assert.NoError(t, err, exprStr)
// expr, err := ParseExpr(helper, exprStr)
@ -68,7 +68,7 @@ func assertValidExpr(t *testing.T, helper *typeutil.SchemaHelper, exprStr string
}
func assertInvalidExpr(t *testing.T, helper *typeutil.SchemaHelper, exprStr string) {
_, err := ParseExpr(helper, exprStr)
_, err := ParseExpr(helper, exprStr, nil)
assert.Error(t, err, exprStr)
}
@ -393,7 +393,7 @@ func TestExpr_Combinations(t *testing.T) {
func TestCreateRetrievePlan(t *testing.T) {
schema := newTestSchemaHelper(t)
_, err := CreateRetrievePlan(schema, "Int64Field > 0")
_, err := CreateRetrievePlan(schema, "Int64Field > 0", nil)
assert.NoError(t, err)
}
@ -404,7 +404,7 @@ func TestCreateSearchPlan(t *testing.T) {
MetricType: "",
SearchParams: "",
RoundDecimal: 0,
})
}, nil)
assert.NoError(t, err)
}
@ -415,7 +415,7 @@ func TestCreateFloat16SearchPlan(t *testing.T) {
MetricType: "",
SearchParams: "",
RoundDecimal: 0,
})
}, nil)
assert.NoError(t, err)
}
@ -426,7 +426,7 @@ func TestCreateBFloat16earchPlan(t *testing.T) {
MetricType: "",
SearchParams: "",
RoundDecimal: 0,
})
}, nil)
assert.NoError(t, err)
}
@ -437,7 +437,7 @@ func TestCreateSparseFloatVectorSearchPlan(t *testing.T) {
MetricType: "",
SearchParams: "",
RoundDecimal: 0,
})
}, nil)
assert.NoError(t, err)
}
@ -582,7 +582,7 @@ func TestExpr_Invalid(t *testing.T) {
`[1,2,3] == 1`,
}
for _, exprStr := range exprStrs {
_, err := ParseExpr(helper, exprStr)
_, err := ParseExpr(helper, exprStr, nil)
assert.Error(t, err, exprStr)
}
}
@ -590,7 +590,7 @@ func TestExpr_Invalid(t *testing.T) {
func TestCreateRetrievePlan_Invalid(t *testing.T) {
t.Run("invalid expr", func(t *testing.T) {
schema := newTestSchemaHelper(t)
_, err := CreateRetrievePlan(schema, "invalid expression")
_, err := CreateRetrievePlan(schema, "invalid expression", nil)
assert.Error(t, err)
})
}
@ -598,19 +598,19 @@ func TestCreateRetrievePlan_Invalid(t *testing.T) {
func TestCreateSearchPlan_Invalid(t *testing.T) {
t.Run("invalid expr", func(t *testing.T) {
schema := newTestSchemaHelper(t)
_, err := CreateSearchPlan(schema, "invalid expression", "", nil)
_, err := CreateSearchPlan(schema, "invalid expression", "", nil, nil)
assert.Error(t, err)
})
t.Run("invalid vector field", func(t *testing.T) {
schema := newTestSchemaHelper(t)
_, err := CreateSearchPlan(schema, "Int64Field > 0", "not_exist", nil)
_, err := CreateSearchPlan(schema, "Int64Field > 0", "not_exist", nil, nil)
assert.Error(t, err)
})
t.Run("not vector type", func(t *testing.T) {
schema := newTestSchemaHelper(t)
_, err := CreateSearchPlan(schema, "Int64Field > 0", "VarCharField", nil)
_, err := CreateSearchPlan(schema, "Int64Field > 0", "VarCharField", nil, nil)
assert.Error(t, err)
})
}
@ -754,7 +754,7 @@ func Test_JSONExpr(t *testing.T) {
MetricType: "",
SearchParams: "",
RoundDecimal: 0,
})
}, nil)
assert.NoError(t, err)
}
}
@ -783,7 +783,7 @@ func Test_InvalidExprOnJSONField(t *testing.T) {
MetricType: "",
SearchParams: "",
RoundDecimal: 0,
})
}, nil)
assert.Error(t, err, expr)
}
}
@ -820,7 +820,7 @@ func Test_InvalidExprWithoutJSONField(t *testing.T) {
MetricType: "",
SearchParams: "",
RoundDecimal: 0,
})
}, nil)
assert.Error(t, err)
}
}
@ -857,7 +857,7 @@ func Test_InvalidExprWithMultipleJSONField(t *testing.T) {
MetricType: "",
SearchParams: "",
RoundDecimal: 0,
})
}, nil)
assert.Error(t, err)
}
}
@ -878,7 +878,7 @@ func Test_exprWithSingleQuotes(t *testing.T) {
MetricType: "",
SearchParams: "",
RoundDecimal: 0,
})
}, nil)
assert.NoError(t, err)
}
@ -893,7 +893,7 @@ func Test_exprWithSingleQuotes(t *testing.T) {
MetricType: "",
SearchParams: "",
RoundDecimal: 0,
})
}, nil)
assert.Error(t, err)
}
}
@ -927,7 +927,7 @@ func Test_JSONContains(t *testing.T) {
MetricType: "",
SearchParams: "",
RoundDecimal: 0,
})
}, nil)
assert.NoError(t, err)
}
}
@ -958,7 +958,7 @@ func Test_InvalidJSONContains(t *testing.T) {
MetricType: "",
SearchParams: "",
RoundDecimal: 0,
})
}, nil)
assert.Error(t, err)
}
}
@ -1021,7 +1021,7 @@ func Test_EscapeString(t *testing.T) {
MetricType: "",
SearchParams: "",
RoundDecimal: 0,
})
}, nil)
assert.NoError(t, err)
}
@ -1038,7 +1038,7 @@ c'`,
MetricType: "",
SearchParams: "",
RoundDecimal: 0,
})
}, nil)
assert.Error(t, err)
fmt.Println(plan)
}
@ -1064,7 +1064,7 @@ func Test_JSONContainsAll(t *testing.T) {
MetricType: "",
SearchParams: "",
RoundDecimal: 0,
})
}, nil)
assert.NoError(t, err)
assert.NotNil(t, plan.GetVectorAnns().GetPredicates().GetJsonContainsExpr())
assert.Equal(t, planpb.JSONContainsExpr_ContainsAll, plan.GetVectorAnns().GetPredicates().GetJsonContainsExpr().GetOp())
@ -1085,7 +1085,7 @@ func Test_JSONContainsAll(t *testing.T) {
MetricType: "",
SearchParams: "",
RoundDecimal: 0,
})
}, nil)
assert.Error(t, err)
}
}
@ -1110,7 +1110,7 @@ func Test_JSONContainsAny(t *testing.T) {
MetricType: "",
SearchParams: "",
RoundDecimal: 0,
})
}, nil)
assert.NoError(t, err)
assert.NotNil(t, plan.GetVectorAnns().GetPredicates().GetJsonContainsExpr())
assert.Equal(t, planpb.JSONContainsExpr_ContainsAny, plan.GetVectorAnns().GetPredicates().GetJsonContainsExpr().GetOp())
@ -1131,7 +1131,7 @@ func Test_JSONContainsAny(t *testing.T) {
MetricType: "",
SearchParams: "",
RoundDecimal: 0,
})
}, nil)
assert.Error(t, err)
}
}
@ -1171,6 +1171,7 @@ func Test_ArrayExpr(t *testing.T) {
`100 > ArrayField[0] > 0`,
`ArrayField[0] > 1`,
`ArrayField[0] == 1`,
`ArrayField in []`,
}
for _, expr = range exprs {
_, err = CreateSearchPlan(schema, expr, "FloatVectorField", &planpb.QueryInfo{
@ -1178,7 +1179,7 @@ func Test_ArrayExpr(t *testing.T) {
MetricType: "",
SearchParams: "",
RoundDecimal: 0,
})
}, nil)
assert.NoError(t, err, expr)
}
@ -1197,7 +1198,6 @@ func Test_ArrayExpr(t *testing.T) {
`ArrayField + 3 == 1`,
`ArrayField in [1,2,3]`,
`ArrayField[0] in [1, "abc",3.3]`,
`ArrayField in []`,
`0 < ArrayField < 100`,
`100 > ArrayField > 0`,
`ArrayField > 1`,
@ -1213,7 +1213,7 @@ func Test_ArrayExpr(t *testing.T) {
MetricType: "",
SearchParams: "",
RoundDecimal: 0,
})
}, nil)
assert.Error(t, err, expr)
}
}
@ -1241,7 +1241,7 @@ func Test_ArrayLength(t *testing.T) {
MetricType: "",
SearchParams: "",
RoundDecimal: 0,
})
}, nil)
assert.NoError(t, err, expr)
}
@ -1267,7 +1267,7 @@ func Test_ArrayLength(t *testing.T) {
MetricType: "",
SearchParams: "",
RoundDecimal: 0,
})
}, nil)
assert.Error(t, err, expr)
}
}
@ -1303,7 +1303,7 @@ func BenchmarkWithString(b *testing.B) {
MetricType: "",
SearchParams: "",
RoundDecimal: 0,
})
}, nil)
assert.NoError(b, err)
assert.NotNil(b, plan)
}
@ -1324,3 +1324,30 @@ func Test_convertHanToASCII(t *testing.T) {
assert.Equal(t, c.target, convertHanToASCII(c.source))
}
}
func BenchmarkTemplateWithString(b *testing.B) {
schema := newTestSchema()
schemaHelper, err := typeutil.CreateSchemaHelper(schema)
require.NoError(b, err)
elements := make([]interface{}, 100)
for i := 0; i < 100; i++ {
elements[i] = generateExpressionFieldData(schemapb.DataType_String, fmt.Sprintf(`"%s",`, randomChineseString(rand.Intn(100))))
}
expr := "StringField in {list}"
mv := map[string]*schemapb.TemplateValue{
"list": generateExpressionFieldData(schemapb.DataType_Array, elements),
}
for i := 0; i < b.N; i++ {
plan, err := CreateSearchPlan(schemaHelper, expr, "FloatVectorField", &planpb.QueryInfo{
Topk: 0,
MetricType: "",
SearchParams: "",
RoundDecimal: 0,
}, mv)
assert.NoError(b, err)
assert.NotNil(b, plan)
}
}

255
internal/parser/planparserv2/utils.go
View File

@ -1,6 +1,7 @@
package planparserv2
import (
"encoding/json"
"fmt"
"strconv"
"strings"
@ -86,6 +87,19 @@ func NewString(value string) *planpb.GenericValue {
}
}
func toColumnExpr(info *planpb.ColumnInfo) *ExprWithType {
return &ExprWithType{
expr: &planpb.Expr{
Expr: &planpb.Expr_ColumnExpr{
ColumnExpr: &planpb.ColumnExpr{
Info: info,
},
},
},
dataType: info.GetDataType(),
}
}
func toValueExpr(n *planpb.GenericValue) *ExprWithType {
expr := &planpb.Expr{
Expr: &planpb.Expr_ValueExpr{
@ -126,14 +140,7 @@ func toValueExpr(n *planpb.GenericValue) *ExprWithType {
}
}
func getSameType(left, right *ExprWithType) (schemapb.DataType, error) {
lDataType, rDataType := left.dataType, right.dataType
if typeutil.IsArrayType(lDataType) {
lDataType = toColumnInfo(left).GetElementType()
}
if typeutil.IsArrayType(rDataType) {
rDataType = toColumnInfo(right).GetElementType()
}
func getTargetType(lDataType, rDataType schemapb.DataType) (schemapb.DataType, error) {
if typeutil.IsJSONType(lDataType) {
if typeutil.IsJSONType(rDataType) {
return schemapb.DataType_JSON, nil
@ -162,6 +169,17 @@ func getSameType(left, right *ExprWithType) (schemapb.DataType, error) {
return schemapb.DataType_None, fmt.Errorf("incompatible data type, %s, %s", lDataType.String(), rDataType.String())
}
func getSameType(left, right *ExprWithType) (schemapb.DataType, error) {
lDataType, rDataType := left.dataType, right.dataType
if typeutil.IsArrayType(lDataType) {
lDataType = toColumnInfo(left).GetElementType()
}
if typeutil.IsArrayType(rDataType) {
rDataType = toColumnInfo(right).GetElementType()
}
return getTargetType(lDataType, rDataType)
}
func calcDataType(left, right *ExprWithType, reverse bool) (schemapb.DataType, error) {
if reverse {
return getSameType(right, left)
@ -223,47 +241,43 @@ func castValue(dataType schemapb.DataType, value *planpb.GenericValue) (*planpb.
return nil, fmt.Errorf("cannot cast value to %s, value: %s", dataType.String(), value)
}
func combineBinaryArithExpr(op planpb.OpType, arithOp planpb.ArithOpType, columnInfo *planpb.ColumnInfo, operand *planpb.GenericValue, value *planpb.GenericValue) *planpb.Expr {
dataType := columnInfo.GetDataType()
if typeutil.IsArrayType(dataType) && len(columnInfo.GetNestedPath()) != 0 {
dataType = columnInfo.GetElementType()
}
castedValue, err := castValue(dataType, operand)
if err != nil {
return nil
}
func combineBinaryArithExpr(op planpb.OpType, arithOp planpb.ArithOpType, columnInfo *planpb.ColumnInfo, arithExprDataType schemapb.DataType, operandExpr, valueExpr *planpb.ValueExpr) *planpb.Expr {
return &planpb.Expr{
Expr: &planpb.Expr_BinaryArithOpEvalRangeExpr{
BinaryArithOpEvalRangeExpr: &planpb.BinaryArithOpEvalRangeExpr{
ColumnInfo: columnInfo,
ArithOp: arithOp,
RightOperand: castedValue,
Op: op,
Value: value,
ColumnInfo: columnInfo,
ArithOp: arithOp,
RightOperand: operandExpr.GetValue(),
Op: op,
Value: valueExpr.GetValue(),
OperandTemplateVariableName: operandExpr.GetTemplateVariableName(),
ValueTemplateVariableName: valueExpr.GetTemplateVariableName(),
},
},
IsTemplate: isTemplateExpr(operandExpr) || isTemplateExpr(valueExpr),
}
}
func combineArrayLengthExpr(op planpb.OpType, arithOp planpb.ArithOpType, columnInfo *planpb.ColumnInfo, value *planpb.GenericValue) (*planpb.Expr, error) {
func combineArrayLengthExpr(op planpb.OpType, arithOp planpb.ArithOpType, columnInfo *planpb.ColumnInfo, valueExpr *planpb.ValueExpr) (*planpb.Expr, error) {
return &planpb.Expr{
Expr: &planpb.Expr_BinaryArithOpEvalRangeExpr{
BinaryArithOpEvalRangeExpr: &planpb.BinaryArithOpEvalRangeExpr{
ColumnInfo: columnInfo,
ArithOp: arithOp,
Op: op,
Value: value,
ColumnInfo: columnInfo,
ArithOp: arithOp,
Op: op,
Value: valueExpr.GetValue(),
ValueTemplateVariableName: valueExpr.GetTemplateVariableName(),
},
},
}, nil
}
func handleBinaryArithExpr(op planpb.OpType, arithExpr *planpb.BinaryArithExpr, valueExpr *planpb.ValueExpr) (*planpb.Expr, error) {
func handleBinaryArithExpr(op planpb.OpType, arithExpr *planpb.BinaryArithExpr, arithExprDataType schemapb.DataType, valueExpr *planpb.ValueExpr) (*planpb.Expr, error) {
leftExpr, leftValue := arithExpr.Left.GetColumnExpr(), arithExpr.Left.GetValueExpr()
rightExpr, rightValue := arithExpr.Right.GetColumnExpr(), arithExpr.Right.GetValueExpr()
arithOp := arithExpr.GetOp()
if arithOp == planpb.ArithOpType_ArrayLength {
return combineArrayLengthExpr(op, arithOp, leftExpr.GetInfo(), valueExpr.GetValue())
return combineArrayLengthExpr(op, arithOp, leftExpr.GetInfo(), valueExpr)
}
if leftExpr != nil && rightExpr != nil {
@ -282,7 +296,7 @@ func handleBinaryArithExpr(op planpb.OpType, arithExpr *planpb.BinaryArithExpr,
// a * 2 == 3
// a / 2 == 3
// a % 2 == 3
return combineBinaryArithExpr(op, arithOp, leftExpr.GetInfo(), rightValue.GetValue(), valueExpr.GetValue()), nil
return combineBinaryArithExpr(op, arithOp, leftExpr.GetInfo(), arithExprDataType, rightValue, valueExpr), nil
} else if rightExpr != nil && leftValue != nil {
// 2 + a == 3
// 2 - a == 3
@ -292,7 +306,7 @@ func handleBinaryArithExpr(op planpb.OpType, arithExpr *planpb.BinaryArithExpr,
switch arithExpr.GetOp() {
case planpb.ArithOpType_Add, planpb.ArithOpType_Mul:
return combineBinaryArithExpr(op, arithOp, rightExpr.GetInfo(), leftValue.GetValue(), valueExpr.GetValue()), nil
return combineBinaryArithExpr(op, arithOp, rightExpr.GetInfo(), arithExprDataType, leftValue, valueExpr), nil
default:
return nil, fmt.Errorf("module field is not yet supported")
}
@ -307,13 +321,17 @@ func handleCompareRightValue(op planpb.OpType, left *ExprWithType, right *planpb
if typeutil.IsArrayType(dataType) && len(toColumnInfo(left).GetNestedPath()) != 0 {
dataType = toColumnInfo(left).GetElementType()
}
castedValue, err := castValue(dataType, right.GetValue())
if err != nil {
return nil, err
if !left.expr.GetIsTemplate() && !isTemplateExpr(right) {
castedValue, err := castValue(dataType, right.GetValue())
if err != nil {
return nil, err
}
right = &planpb.ValueExpr{Value: castedValue}
}
if leftArithExpr := left.expr.GetBinaryArithExpr(); leftArithExpr != nil {
return handleBinaryArithExpr(op, leftArithExpr, &planpb.ValueExpr{Value: castedValue})
return handleBinaryArithExpr(op, leftArithExpr, left.dataType, right)
}
columnInfo := toColumnInfo(left)
@ -323,11 +341,13 @@ func handleCompareRightValue(op planpb.OpType, left *ExprWithType, right *planpb
expr := &planpb.Expr{
Expr: &planpb.Expr_UnaryRangeExpr{
UnaryRangeExpr: &planpb.UnaryRangeExpr{
ColumnInfo: columnInfo,
Op: op,
Value: castedValue,
ColumnInfo: columnInfo,
Op: op,
Value: right.GetValue(),
TemplateVariableName: right.GetTemplateVariableName(),
},
},
IsTemplate: isTemplateExpr(right),
}
switch op {
@ -342,6 +362,19 @@ func handleCompare(op planpb.OpType, left *ExprWithType, right *ExprWithType) (*
leftColumnInfo := toColumnInfo(left)
rightColumnInfo := toColumnInfo(right)
if left.expr.GetIsTemplate() {
return &planpb.Expr{
Expr: &planpb.Expr_UnaryRangeExpr{
UnaryRangeExpr: &planpb.UnaryRangeExpr{
ColumnInfo: rightColumnInfo,
Op: op,
Value: left.expr.GetValueExpr().GetValue(),
TemplateVariableName: left.expr.GetValueExpr().GetTemplateVariableName(),
},
},
}, nil
}
if leftColumnInfo == nil || rightColumnInfo == nil {
return nil, fmt.Errorf("only comparison between two fields is supported")
}
@ -417,9 +450,11 @@ func getDataType(expr *ExprWithType) string {
}
func HandleCompare(op int, left, right *ExprWithType) (*planpb.Expr, error) {
if !canBeCompared(left, right) {
return nil, fmt.Errorf("comparisons between %s and %s are not supported",
getDataType(left), getDataType(right))
if !left.expr.GetIsTemplate() && !right.expr.GetIsTemplate() {
if !canBeCompared(left, right) {
return nil, fmt.Errorf("comparisons between %s and %s are not supported",
getDataType(left), getDataType(right))
}
}
cmpOp := cmpOpMap[op]
@ -521,23 +556,39 @@ func canArithmeticDataType(left, right schemapb.DataType) bool {
}
}
func canArithmetic(left *ExprWithType, right *ExprWithType) bool {
if !typeutil.IsArrayType(left.dataType) && !typeutil.IsArrayType(right.dataType) {
return canArithmeticDataType(left.dataType, right.dataType)
//func canArithmetic(left *ExprWithType, right *ExprWithType) bool {
// if !typeutil.IsArrayType(left.dataType) && !typeutil.IsArrayType(right.dataType) {
// return canArithmeticDataType(left.dataType, right.dataType)
// }
// if typeutil.IsArrayType(left.dataType) && typeutil.IsArrayType(right.dataType) {
// return canArithmeticDataType(getArrayElementType(left), getArrayElementType(right))
// }
// if typeutil.IsArrayType(left.dataType) {
// return canArithmeticDataType(getArrayElementType(left), right.dataType)
// }
// return canArithmeticDataType(left.dataType, getArrayElementType(right))
//}
func canArithmetic(left, leftElement, right, rightElement schemapb.DataType) bool {
if !typeutil.IsArrayType(left) && !typeutil.IsArrayType(right) {
return canArithmeticDataType(left, right)
}
if typeutil.IsArrayType(left.dataType) && typeutil.IsArrayType(right.dataType) {
return canArithmeticDataType(getArrayElementType(left), getArrayElementType(right))
if typeutil.IsArrayType(left) && typeutil.IsArrayType(right) {
return canArithmeticDataType(leftElement, rightElement)
}
if typeutil.IsArrayType(left.dataType) {
return canArithmeticDataType(getArrayElementType(left), right.dataType)
if typeutil.IsArrayType(left) {
return canArithmeticDataType(leftElement, right)
}
return canArithmeticDataType(left.dataType, getArrayElementType(right))
return canArithmeticDataType(left, rightElement)
}
func canConvertToIntegerType(dataType, elementType schemapb.DataType) bool {
return typeutil.IsIntegerType(dataType) || typeutil.IsJSONType(dataType) ||
(typeutil.IsArrayType(dataType) && typeutil.IsIntegerType(elementType))
}
func isIntegerColumn(col *planpb.ColumnInfo) bool {
return typeutil.IsIntegerType(col.GetDataType()) ||
(typeutil.IsArrayType(col.GetDataType()) && typeutil.IsIntegerType(col.GetElementType())) ||
typeutil.IsJSONType(col.GetDataType())
return canConvertToIntegerType(col.GetDataType(), col.GetElementType())
}
func isEscapeCh(ch uint8) bool {
@ -561,3 +612,103 @@ func hexDigit(n uint32) byte {
}
return byte(n-10) + 'a'
}
func checkValidModArith(tokenType planpb.ArithOpType, leftType, leftElementType, rightType, rightElementType schemapb.DataType) error {
switch tokenType {
case planpb.ArithOpType_Mod:
if !canConvertToIntegerType(leftType, leftElementType) || !canConvertToIntegerType(rightType, rightElementType) {
return fmt.Errorf("modulo can only apply on integer types")
}
default:
}
return nil
}
func checkRangeCompared(dataType schemapb.DataType, value *planpb.GenericValue) error {
switch dataType {
case schemapb.DataType_String, schemapb.DataType_VarChar:
if !IsString(value) {
return fmt.Errorf("invalid range operations")
}
case schemapb.DataType_Bool:
return fmt.Errorf("invalid range operations on boolean expr")
case schemapb.DataType_Int8, schemapb.DataType_Int16, schemapb.DataType_Int32, schemapb.DataType_Int64:
if !IsInteger(value) {
return fmt.Errorf("invalid range operations")
}
case schemapb.DataType_Float, schemapb.DataType_Double:
if !IsNumber(value) {
return fmt.Errorf("invalid range operations")
}
}
return nil
}
func checkContainsElement(columnExpr *ExprWithType, op planpb.JSONContainsExpr_JSONOp, elementValue *planpb.GenericValue) error {
if op != planpb.JSONContainsExpr_Contains && elementValue.GetArrayVal() == nil {
return fmt.Errorf("%s operation element must be an array", op.String())
}
if typeutil.IsArrayType(columnExpr.expr.GetColumnExpr().GetInfo().GetDataType()) {
var elements []*planpb.GenericValue
if op == planpb.JSONContainsExpr_Contains {
elements = []*planpb.GenericValue{elementValue}
} else {
elements = elementValue.GetArrayVal().GetArray()
}
for _, value := range elements {
valExpr := toValueExpr(value)
if !canBeCompared(columnExpr, valExpr) {
return fmt.Errorf("%s operation can't compare between array element type: %s and %s",
op.String(),
columnExpr.expr.GetColumnExpr().GetInfo().GetElementType(),
valExpr.dataType)
}
}
}
return nil
}
func parseJSONValue(value interface{}) (*planpb.GenericValue, schemapb.DataType, error) {
switch v := value.(type) {
case json.Number:
if intValue, err := v.Int64(); err == nil {
return NewInt(intValue), schemapb.DataType_Int64, nil
} else if floatValue, err := v.Float64(); err == nil {
return NewFloat(floatValue), schemapb.DataType_Double, nil
} else {
return nil, schemapb.DataType_None, fmt.Errorf("%v is a number, but couldn't convert it", value)
}
case string:
return NewString(v), schemapb.DataType_String, nil
case bool:
return NewBool(v), schemapb.DataType_Bool, nil
case []interface{}:
arrayElements := make([]*planpb.GenericValue, len(v))
dataType := schemapb.DataType_None
sameType := true
for i, elem := range v {
ev, dt, err := parseJSONValue(elem)
if err != nil {
return nil, schemapb.DataType_None, err
}
if dataType == schemapb.DataType_None {
dataType = dt
} else if dataType != dt {
sameType = false
}
arrayElements[i] = ev
}
return &planpb.GenericValue{
Val: &planpb.GenericValue_ArrayVal{
ArrayVal: &planpb.Array{
Array: arrayElements,
SameType: sameType,
ElementType: dataType,
},
},
}, schemapb.DataType_Array, nil
default:
return nil, schemapb.DataType_None, fmt.Errorf("%v is of unknown type: %T\n", value, v)
}
}

9
internal/proto/plan.proto
View File

@ -84,12 +84,14 @@ message ExistsExpr {
message ValueExpr {
GenericValue value = 1;
string template_variable_name = 2;
}
message UnaryRangeExpr {
ColumnInfo column_info = 1;
OpType op = 2;
GenericValue value = 3;
string template_variable_name = 4;
}
message BinaryRangeExpr {
@ -98,6 +100,8 @@ message BinaryRangeExpr {
bool upper_inclusive = 3;
GenericValue lower_value = 4;
GenericValue upper_value = 5;
string lower_template_variable_name = 6;
string upper_template_variable_name = 7;
}
message CompareExpr {
@ -110,6 +114,7 @@ message TermExpr {
ColumnInfo column_info = 1;
repeated GenericValue values = 2;
bool is_in_field = 3;
string template_variable_name = 4;
}
message JSONContainsExpr {
@ -127,6 +132,7 @@ message JSONContainsExpr {
}
JSONOp op = 3;
bool elements_same_type = 4;
string template_variable_name = 5;
}
message UnaryExpr {
@ -167,6 +173,8 @@ message BinaryArithOpEvalRangeExpr {
GenericValue right_operand = 3;
OpType op = 4;
GenericValue value = 5;
string operand_template_variable_name = 6;
string value_template_variable_name = 7;
}
message AlwaysTrueExpr {}
@ -187,6 +195,7 @@ message Expr {
AlwaysTrueExpr always_true_expr = 12;
JSONContainsExpr json_contains_expr = 13;
};
bool is_template = 20;
}
message VectorANNS {

1
internal/proxy/task.go
View File

@ -54,6 +54,7 @@ const (
NQKey = "nq"
MetricTypeKey = common.MetricTypeKey
SearchParamsKey = "params"
ExprParamsKey = "expr_params"
RoundDecimalKey = "round_decimal"
OffsetKey = "offset"
LimitKey = "limit"

2
internal/proxy/task_delete.go
View File

@ -367,7 +367,7 @@ func (dr *deleteRunner) Init(ctx context.Context) error {
}
func (dr *deleteRunner) Run(ctx context.Context) error {
plan, err := planparserv2.CreateRetrievePlan(dr.schema.schemaHelper, dr.req.GetExpr())
plan, err := planparserv2.CreateRetrievePlan(dr.schema.schemaHelper, dr.req.GetExpr(), dr.req.GetExprTemplateValues())
if err != nil {
return merr.WrapErrAsInputError(merr.WrapErrParameterInvalidMsg("failed to create delete plan: %v", err))
}

16
internal/proxy/task_delete_test.go
View File

@ -53,7 +53,7 @@ func Test_getPrimaryKeysFromPlan(t *testing.T) {
t.Run("delete with complex pk expr", func(t *testing.T) {
expr := "pk < 4"
plan, err := planparserv2.CreateRetrievePlan(schema, expr)
plan, err := planparserv2.CreateRetrievePlan(schema, expr, nil)
assert.NoError(t, err)
isSimple, _, _ := getPrimaryKeysFromPlan(collSchema, plan)
assert.False(t, isSimple)
@ -61,7 +61,7 @@ func Test_getPrimaryKeysFromPlan(t *testing.T) {
t.Run("delete with no-pk field expr", func(t *testing.T) {
expr := "non_pk == 1"
plan, err := planparserv2.CreateRetrievePlan(schema, expr)
plan, err := planparserv2.CreateRetrievePlan(schema, expr, nil)
assert.NoError(t, err)
isSimple, _, _ := getPrimaryKeysFromPlan(collSchema, plan)
assert.False(t, isSimple)
@ -69,7 +69,7 @@ func Test_getPrimaryKeysFromPlan(t *testing.T) {
t.Run("delete with simple term expr", func(t *testing.T) {
expr := "pk in [1, 2, 3]"
plan, err := planparserv2.CreateRetrievePlan(schema, expr)
plan, err := planparserv2.CreateRetrievePlan(schema, expr, nil)
assert.NoError(t, err)
isSimple, _, rowNum := getPrimaryKeysFromPlan(collSchema, plan)
assert.True(t, isSimple)
@ -78,7 +78,7 @@ func Test_getPrimaryKeysFromPlan(t *testing.T) {
t.Run("delete failed with simple term expr", func(t *testing.T) {
expr := "pk in [1, 2, 3]"
plan, err := planparserv2.CreateRetrievePlan(schema, expr)
plan, err := planparserv2.CreateRetrievePlan(schema, expr, nil)
assert.NoError(t, err)
termExpr := plan.Node.(*planpb.PlanNode_Query).Query.Predicates.Expr.(*planpb.Expr_TermExpr)
termExpr.TermExpr.ColumnInfo.DataType = -1
@ -89,7 +89,7 @@ func Test_getPrimaryKeysFromPlan(t *testing.T) {
t.Run("delete with simple equal expr", func(t *testing.T) {
expr := "pk == 1"
plan, err := planparserv2.CreateRetrievePlan(schema, expr)
plan, err := planparserv2.CreateRetrievePlan(schema, expr, nil)
assert.NoError(t, err)
isSimple, _, rowNum := getPrimaryKeysFromPlan(collSchema, plan)
assert.True(t, isSimple)
@ -98,7 +98,7 @@ func Test_getPrimaryKeysFromPlan(t *testing.T) {
t.Run("delete failed with simple equal expr", func(t *testing.T) {
expr := "pk == 1"
plan, err := planparserv2.CreateRetrievePlan(schema, expr)
plan, err := planparserv2.CreateRetrievePlan(schema, expr, nil)
assert.NoError(t, err)
unaryRangeExpr := plan.Node.(*planpb.PlanNode_Query).Query.Predicates.Expr.(*planpb.Expr_UnaryRangeExpr)
unaryRangeExpr.UnaryRangeExpr.ColumnInfo.DataType = -1
@ -1054,7 +1054,7 @@ func TestDeleteRunner_StreamingQueryAndDelteFunc(t *testing.T) {
schemaHelper, err := typeutil.CreateSchemaHelper(dr.schema.CollectionSchema)
require.NoError(t, err)
plan, err := planparserv2.CreateRetrievePlan(schemaHelper, dr.req.Expr)
plan, err := planparserv2.CreateRetrievePlan(schemaHelper, dr.req.Expr, nil)
assert.NoError(t, err)
queryFunc := dr.getStreamingQueryAndDelteFunc(plan)
assert.Error(t, queryFunc(ctx, 1, qn, ""))
@ -1099,7 +1099,7 @@ func TestDeleteRunner_StreamingQueryAndDelteFunc(t *testing.T) {
schemaHelper, err := typeutil.CreateSchemaHelper(dr.schema.CollectionSchema)
require.NoError(t, err)
plan, err := planparserv2.CreateRetrievePlan(schemaHelper, dr.req.Expr)
plan, err := planparserv2.CreateRetrievePlan(schemaHelper, dr.req.Expr, nil)
assert.NoError(t, err)
queryFunc := dr.getStreamingQueryAndDelteFunc(plan)
assert.Error(t, queryFunc(ctx, 1, qn, ""))

9
internal/proxy/task_query.go
View File

@ -189,7 +189,7 @@ func matchCountRule(outputs []string) bool {
return len(outputs) == 1 && strings.ToLower(strings.TrimSpace(outputs[0])) == "count(*)"
}
func createCntPlan(expr string, schemaHelper *typeutil.SchemaHelper) (*planpb.PlanNode, error) {
func createCntPlan(expr string, schemaHelper *typeutil.SchemaHelper, exprTemplateValues map[string]*schemapb.TemplateValue) (*planpb.PlanNode, error) {
if expr == "" {
return &planpb.PlanNode{
Node: &planpb.PlanNode_Query{
@ -200,8 +200,7 @@ func createCntPlan(expr string, schemaHelper *typeutil.SchemaHelper) (*planpb.Pl
},
}, nil
}
plan, err := planparserv2.CreateRetrievePlan(schemaHelper, expr)
plan, err := planparserv2.CreateRetrievePlan(schemaHelper, expr, exprTemplateValues)
if err != nil {
return nil, merr.WrapErrAsInputError(merr.WrapErrParameterInvalidMsg("failed to create query plan: %v", err))
}
@ -217,14 +216,14 @@ func (t *queryTask) createPlan(ctx context.Context) error {
cntMatch := matchCountRule(t.request.GetOutputFields())
if cntMatch {
var err error
t.plan, err = createCntPlan(t.request.GetExpr(), schema.schemaHelper)
t.plan, err = createCntPlan(t.request.GetExpr(), schema.schemaHelper, t.request.GetExprTemplateValues())
t.userOutputFields = []string{"count(*)"}
return err
}
var err error
if t.plan == nil {
t.plan, err = planparserv2.CreateRetrievePlan(schema.schemaHelper, t.request.Expr)
t.plan, err = planparserv2.CreateRetrievePlan(schema.schemaHelper, t.request.Expr, t.request.GetExprTemplateValues())
if err != nil {
return merr.WrapErrAsInputError(merr.WrapErrParameterInvalidMsg("failed to create query plan: %v", err))
}

4
internal/proxy/task_query_test.go
View File

@ -867,7 +867,7 @@ func Test_matchCountRule(t *testing.T) {
func Test_createCntPlan(t *testing.T) {
t.Run("plan without filter", func(t *testing.T) {
plan, err := createCntPlan("", nil)
plan, err := createCntPlan("", nil, nil)
assert.NoError(t, err)
assert.True(t, plan.GetQuery().GetIsCount())
assert.Nil(t, plan.GetQuery().GetPredicates())
@ -886,7 +886,7 @@ func Test_createCntPlan(t *testing.T) {
}
schemaHelper, err := typeutil.CreateSchemaHelper(schema)
require.NoError(t, err)
plan, err := createCntPlan("a > 4", schemaHelper)
plan, err := createCntPlan("a > 4", schemaHelper, nil)
assert.NoError(t, err)
assert.True(t, plan.GetQuery().GetIsCount())
assert.NotNil(t, plan.GetQuery().GetPredicates())

9
internal/proxy/task_search.go
View File

@ -351,7 +351,7 @@ func (t *searchTask) initAdvancedSearchRequest(ctx context.Context) error {
t.SearchRequest.SubReqs = make([]*internalpb.SubSearchRequest, len(t.request.GetSubReqs()))
t.queryInfos = make([]*planpb.QueryInfo, len(t.request.GetSubReqs()))
for index, subReq := range t.request.GetSubReqs() {
plan, queryInfo, offset, err := t.tryGeneratePlan(subReq.GetSearchParams(), subReq.GetDsl())
plan, queryInfo, offset, err := t.tryGeneratePlan(subReq.GetSearchParams(), subReq.GetDsl(), subReq.GetExprTemplateValues())
if err != nil {
return err
}
@ -427,7 +427,7 @@ func (t *searchTask) initSearchRequest(ctx context.Context) error {
log := log.Ctx(ctx).With(zap.Int64("collID", t.GetCollectionID()), zap.String("collName", t.collectionName))
// fetch search_growing from search param
plan, queryInfo, offset, err := t.tryGeneratePlan(t.request.GetSearchParams(), t.request.GetDsl())
plan, queryInfo, offset, err := t.tryGeneratePlan(t.request.GetSearchParams(), t.request.GetDsl(), t.request.GetExprTemplateValues())
if err != nil {
return err
}
@ -473,7 +473,7 @@ func (t *searchTask) initSearchRequest(ctx context.Context) error {
return nil
}
func (t *searchTask) tryGeneratePlan(params []*commonpb.KeyValuePair, dsl string) (*planpb.PlanNode, *planpb.QueryInfo, int64, error) {
func (t *searchTask) tryGeneratePlan(params []*commonpb.KeyValuePair, dsl string, exprTemplateValues map[string]*schemapb.TemplateValue) (*planpb.PlanNode, *planpb.QueryInfo, int64, error) {
annsFieldName, err := funcutil.GetAttrByKeyFromRepeatedKV(AnnsFieldKey, params)
if err != nil || len(annsFieldName) == 0 {
vecFields := typeutil.GetVectorFieldSchemas(t.schema.CollectionSchema)
@ -494,7 +494,8 @@ func (t *searchTask) tryGeneratePlan(params []*commonpb.KeyValuePair, dsl string
if queryInfo.GetGroupByFieldId() != -1 && annField.GetDataType() == schemapb.DataType_BinaryVector {
return nil, nil, 0, errors.New("not support search_group_by operation based on binary vector column")
}
plan, planErr := planparserv2.CreateSearchPlan(t.schema.schemaHelper, dsl, annsFieldName, queryInfo)
plan, planErr := planparserv2.CreateSearchPlan(t.schema.schemaHelper, dsl, annsFieldName, queryInfo, exprTemplateValues)
if planErr != nil {
log.Warn("failed to create query plan", zap.Error(planErr),
zap.String("dsl", dsl), // may be very large if large term passed.

70
internal/querynodev2/delegator/segment_pruner_test.go
View File

@ -232,7 +232,7 @@ func (sps *SegmentPrunerSuite) TestPruneSegmentsByScalarIntField() {
copy(testSegments, sps.sealedSegments)
exprStr := "age==156"
schemaHelper, _ := typeutil.CreateSchemaHelper(sps.schema)
planNode, err := planparserv2.CreateRetrievePlan(schemaHelper, exprStr)
planNode, err := planparserv2.CreateRetrievePlan(schemaHelper, exprStr, nil)
sps.NoError(err)
serializedPlan, _ := proto.Marshal(planNode)
queryReq := &internalpb.RetrieveRequest{
@ -249,7 +249,7 @@ func (sps *SegmentPrunerSuite) TestPruneSegmentsByScalarIntField() {
copy(testSegments, sps.sealedSegments)
exprStr := "age!=156"
schemaHelper, _ := typeutil.CreateSchemaHelper(sps.schema)
planNode, err := planparserv2.CreateRetrievePlan(schemaHelper, exprStr)
planNode, err := planparserv2.CreateRetrievePlan(schemaHelper, exprStr, nil)
sps.NoError(err)
serializedPlan, _ := proto.Marshal(planNode)
queryReq := &internalpb.RetrieveRequest{
@ -266,7 +266,7 @@ func (sps *SegmentPrunerSuite) TestPruneSegmentsByScalarIntField() {
copy(testSegments, sps.sealedSegments)
exprStr := "age in [100,200,300]"
schemaHelper, _ := typeutil.CreateSchemaHelper(sps.schema)
planNode, err := planparserv2.CreateRetrievePlan(schemaHelper, exprStr)
planNode, err := planparserv2.CreateRetrievePlan(schemaHelper, exprStr, nil)
sps.NoError(err)
serializedPlan, _ := proto.Marshal(planNode)
queryReq := &internalpb.RetrieveRequest{
@ -284,7 +284,7 @@ func (sps *SegmentPrunerSuite) TestPruneSegmentsByScalarIntField() {
copy(testSegments, sps.sealedSegments)
exprStr := "age not in [100,200,300]"
schemaHelper, _ := typeutil.CreateSchemaHelper(sps.schema)
planNode, err := planparserv2.CreateRetrievePlan(schemaHelper, exprStr)
planNode, err := planparserv2.CreateRetrievePlan(schemaHelper, exprStr, nil)
sps.NoError(err)
serializedPlan, _ := proto.Marshal(planNode)
queryReq := &internalpb.RetrieveRequest{
@ -301,7 +301,7 @@ func (sps *SegmentPrunerSuite) TestPruneSegmentsByScalarIntField() {
copy(testSegments, sps.sealedSegments)
exprStr := "age>=700"
schemaHelper, _ := typeutil.CreateSchemaHelper(sps.schema)
planNode, err := planparserv2.CreateRetrievePlan(schemaHelper, exprStr)
planNode, err := planparserv2.CreateRetrievePlan(schemaHelper, exprStr, nil)
sps.NoError(err)
serializedPlan, _ := proto.Marshal(planNode)
queryReq := &internalpb.RetrieveRequest{
@ -317,7 +317,7 @@ func (sps *SegmentPrunerSuite) TestPruneSegmentsByScalarIntField() {
copy(testSegments, sps.sealedSegments)
exprStr := "age>=500 and age<=550"
schemaHelper, _ := typeutil.CreateSchemaHelper(sps.schema)
planNode, err := planparserv2.CreateRetrievePlan(schemaHelper, exprStr)
planNode, err := planparserv2.CreateRetrievePlan(schemaHelper, exprStr, nil)
sps.NoError(err)
serializedPlan, _ := proto.Marshal(planNode)
queryReq := &internalpb.RetrieveRequest{
@ -333,7 +333,7 @@ func (sps *SegmentPrunerSuite) TestPruneSegmentsByScalarIntField() {
copy(testSegments, sps.sealedSegments)
exprStr := "500<=age<=550"
schemaHelper, _ := typeutil.CreateSchemaHelper(sps.schema)
planNode, err := planparserv2.CreateRetrievePlan(schemaHelper, exprStr)
planNode, err := planparserv2.CreateRetrievePlan(schemaHelper, exprStr, nil)
sps.NoError(err)
serializedPlan, _ := proto.Marshal(planNode)
queryReq := &internalpb.RetrieveRequest{
@ -350,7 +350,7 @@ func (sps *SegmentPrunerSuite) TestPruneSegmentsByScalarIntField() {
copy(testSegments, sps.sealedSegments)
exprStr := "(age>=500 and age<=550) or (age>800 and age<950) or (age>300 and age<330)"
schemaHelper, _ := typeutil.CreateSchemaHelper(sps.schema)
planNode, err := planparserv2.CreateRetrievePlan(schemaHelper, exprStr)
planNode, err := planparserv2.CreateRetrievePlan(schemaHelper, exprStr, nil)
sps.NoError(err)
serializedPlan, _ := proto.Marshal(planNode)
queryReq := &internalpb.RetrieveRequest{
@ -368,7 +368,7 @@ func (sps *SegmentPrunerSuite) TestPruneSegmentsByScalarIntField() {
copy(testSegments, sps.sealedSegments)
exprStr := "(age>=500 and age<=550) or (age>800 and age<950) or (age>300 and age<330) or age < 150"
schemaHelper, _ := typeutil.CreateSchemaHelper(sps.schema)
planNode, err := planparserv2.CreateRetrievePlan(schemaHelper, exprStr)
planNode, err := planparserv2.CreateRetrievePlan(schemaHelper, exprStr, nil)
sps.NoError(err)
serializedPlan, _ := proto.Marshal(planNode)
queryReq := &internalpb.RetrieveRequest{
@ -386,7 +386,7 @@ func (sps *SegmentPrunerSuite) TestPruneSegmentsByScalarIntField() {
copy(testSegments, sps.sealedSegments)
exprStr := "age > 600 or age < 300"
schemaHelper, _ := typeutil.CreateSchemaHelper(sps.schema)
planNode, err := planparserv2.CreateRetrievePlan(schemaHelper, exprStr)
planNode, err := planparserv2.CreateRetrievePlan(schemaHelper, exprStr, nil)
sps.NoError(err)
serializedPlan, _ := proto.Marshal(planNode)
queryReq := &internalpb.RetrieveRequest{
@ -404,7 +404,7 @@ func (sps *SegmentPrunerSuite) TestPruneSegmentsByScalarIntField() {
copy(testSegments, sps.sealedSegments)
exprStr := "age > 600 or age < 30"
schemaHelper, _ := typeutil.CreateSchemaHelper(sps.schema)
planNode, err := planparserv2.CreateRetrievePlan(schemaHelper, exprStr)
planNode, err := planparserv2.CreateRetrievePlan(schemaHelper, exprStr, nil)
sps.NoError(err)
serializedPlan, _ := proto.Marshal(planNode)
queryReq := &internalpb.RetrieveRequest{
@ -429,7 +429,7 @@ func (sps *SegmentPrunerSuite) TestPruneSegmentsWithUnrelatedField() {
exprStr := "age>=500 and age<=550 and info != 'xxx'"
// as info is not cluster key field, so 'and' one more info condition will not influence the pruned result
schemaHelper, _ := typeutil.CreateSchemaHelper(sps.schema)
planNode, err := planparserv2.CreateRetrievePlan(schemaHelper, exprStr)
planNode, err := planparserv2.CreateRetrievePlan(schemaHelper, exprStr, nil)
sps.NoError(err)
serializedPlan, _ := proto.Marshal(planNode)
queryReq := &internalpb.RetrieveRequest{
@ -447,7 +447,7 @@ func (sps *SegmentPrunerSuite) TestPruneSegmentsWithUnrelatedField() {
exprStr := "age>=500 and info != 'xxx' and age<=550"
// as info is not cluster key field, so 'and' one more info condition will not influence the pruned result
schemaHelper, _ := typeutil.CreateSchemaHelper(sps.schema)
planNode, err := planparserv2.CreateRetrievePlan(schemaHelper, exprStr)
planNode, err := planparserv2.CreateRetrievePlan(schemaHelper, exprStr, nil)
sps.NoError(err)
serializedPlan, _ := proto.Marshal(planNode)
queryReq := &internalpb.RetrieveRequest{
@ -465,7 +465,7 @@ func (sps *SegmentPrunerSuite) TestPruneSegmentsWithUnrelatedField() {
exprStr := "age>=500 and age<=550 or info != 'xxx'"
// as info is not cluster key field, so 'or' one more will make it impossible to prune any segments
schemaHelper, _ := typeutil.CreateSchemaHelper(sps.schema)
planNode, err := planparserv2.CreateRetrievePlan(schemaHelper, exprStr)
planNode, err := planparserv2.CreateRetrievePlan(schemaHelper, exprStr, nil)
sps.NoError(err)
serializedPlan, _ := proto.Marshal(planNode)
queryReq := &internalpb.RetrieveRequest{
@ -484,7 +484,7 @@ func (sps *SegmentPrunerSuite) TestPruneSegmentsWithUnrelatedField() {
copy(testSegments, sps.sealedSegments)
exprStr := "(age>=500 and age<=550) or info != 'xxx' or (age>800 and age<950) or (age>300 and age<330) or age < 50"
schemaHelper, _ := typeutil.CreateSchemaHelper(sps.schema)
planNode, err := planparserv2.CreateRetrievePlan(schemaHelper, exprStr)
planNode, err := planparserv2.CreateRetrievePlan(schemaHelper, exprStr, nil)
sps.NoError(err)
serializedPlan, _ := proto.Marshal(planNode)
queryReq := &internalpb.RetrieveRequest{
@ -503,7 +503,7 @@ func (sps *SegmentPrunerSuite) TestPruneSegmentsWithUnrelatedField() {
copy(testSegments, sps.sealedSegments)
exprStr := "(age>=500 and age<=550) and info != 'xxx' or (age>800 and age<950) or (age>300 and age<330) or age < 50"
schemaHelper, _ := typeutil.CreateSchemaHelper(sps.schema)
planNode, err := planparserv2.CreateRetrievePlan(schemaHelper, exprStr)
planNode, err := planparserv2.CreateRetrievePlan(schemaHelper, exprStr, nil)
sps.NoError(err)
serializedPlan, _ := proto.Marshal(planNode)
queryReq := &internalpb.RetrieveRequest{
@ -520,7 +520,7 @@ func (sps *SegmentPrunerSuite) TestPruneSegmentsWithUnrelatedField() {
copy(testSegments, sps.sealedSegments)
exprStr := "info in ['aa','bb','cc']"
schemaHelper, _ := typeutil.CreateSchemaHelper(sps.schema)
planNode, err := planparserv2.CreateRetrievePlan(schemaHelper, exprStr)
planNode, err := planparserv2.CreateRetrievePlan(schemaHelper, exprStr, nil)
sps.NoError(err)
serializedPlan, _ := proto.Marshal(planNode)
queryReq := &internalpb.RetrieveRequest{
@ -544,7 +544,7 @@ func (sps *SegmentPrunerSuite) TestPruneSegmentsByScalarStrField() {
copy(testSegments, sps.sealedSegments)
exprStr := `info=="rag"`
schemaHelper, _ := typeutil.CreateSchemaHelper(sps.schema)
planNode, err := planparserv2.CreateRetrievePlan(schemaHelper, exprStr)
planNode, err := planparserv2.CreateRetrievePlan(schemaHelper, exprStr, nil)
sps.NoError(err)
serializedPlan, _ := proto.Marshal(planNode)
queryReq := &internalpb.RetrieveRequest{
@ -562,7 +562,7 @@ func (sps *SegmentPrunerSuite) TestPruneSegmentsByScalarStrField() {
copy(testSegments, sps.sealedSegments)
exprStr := `info=="kpl"`
schemaHelper, _ := typeutil.CreateSchemaHelper(sps.schema)
planNode, err := planparserv2.CreateRetrievePlan(schemaHelper, exprStr)
planNode, err := planparserv2.CreateRetrievePlan(schemaHelper, exprStr, nil)
sps.NoError(err)
serializedPlan, _ := proto.Marshal(planNode)
queryReq := &internalpb.RetrieveRequest{
@ -580,7 +580,7 @@ func (sps *SegmentPrunerSuite) TestPruneSegmentsByScalarStrField() {
copy(testSegments, sps.sealedSegments)
exprStr := `info<="less"`
schemaHelper, _ := typeutil.CreateSchemaHelper(sps.schema)
planNode, err := planparserv2.CreateRetrievePlan(schemaHelper, exprStr)
planNode, err := planparserv2.CreateRetrievePlan(schemaHelper, exprStr, nil)
sps.NoError(err)
serializedPlan, _ := proto.Marshal(planNode)
queryReq := &internalpb.RetrieveRequest{
@ -765,7 +765,7 @@ func (sps *SegmentPrunerSuite) TestPruneSegmentsVariousIntTypes() {
copy(testSegments, sealedSegments)
exprStr := "int8 > 128"
schemaHelper, _ := typeutil.CreateSchemaHelper(schema)
planNode, err := planparserv2.CreateRetrievePlan(schemaHelper, exprStr)
planNode, err := planparserv2.CreateRetrievePlan(schemaHelper, exprStr, nil)
sps.NoError(err)
serializedPlan, _ := proto.Marshal(planNode)
queryReq := &internalpb.RetrieveRequest{
@ -781,7 +781,7 @@ func (sps *SegmentPrunerSuite) TestPruneSegmentsVariousIntTypes() {
copy(testSegments, sealedSegments)
exprStr := "int8 < -129"
schemaHelper, _ := typeutil.CreateSchemaHelper(schema)
planNode, err := planparserv2.CreateRetrievePlan(schemaHelper, exprStr)
planNode, err := planparserv2.CreateRetrievePlan(schemaHelper, exprStr, nil)
sps.NoError(err)
serializedPlan, _ := proto.Marshal(planNode)
queryReq := &internalpb.RetrieveRequest{
@ -797,7 +797,7 @@ func (sps *SegmentPrunerSuite) TestPruneSegmentsVariousIntTypes() {
copy(testSegments, sealedSegments)
exprStr := "int8 > 50"
schemaHelper, _ := typeutil.CreateSchemaHelper(schema)
planNode, err := planparserv2.CreateRetrievePlan(schemaHelper, exprStr)
planNode, err := planparserv2.CreateRetrievePlan(schemaHelper, exprStr, nil)
sps.NoError(err)
serializedPlan, _ := proto.Marshal(planNode)
queryReq := &internalpb.RetrieveRequest{
@ -914,7 +914,7 @@ func (sps *SegmentPrunerSuite) TestPruneSegmentsVariousIntTypes() {
copy(testSegments, sealedSegments)
exprStr := "int16 > 32768"
schemaHelper, _ := typeutil.CreateSchemaHelper(schema)
planNode, err := planparserv2.CreateRetrievePlan(schemaHelper, exprStr)
planNode, err := planparserv2.CreateRetrievePlan(schemaHelper, exprStr, nil)
sps.NoError(err)
serializedPlan, _ := proto.Marshal(planNode)
queryReq := &internalpb.RetrieveRequest{
@ -930,7 +930,7 @@ func (sps *SegmentPrunerSuite) TestPruneSegmentsVariousIntTypes() {
copy(testSegments, sealedSegments)
exprStr := "int16 < -32769"
schemaHelper, _ := typeutil.CreateSchemaHelper(schema)
planNode, err := planparserv2.CreateRetrievePlan(schemaHelper, exprStr)
planNode, err := planparserv2.CreateRetrievePlan(schemaHelper, exprStr, nil)
sps.NoError(err)
serializedPlan, _ := proto.Marshal(planNode)
queryReq := &internalpb.RetrieveRequest{
@ -945,7 +945,7 @@ func (sps *SegmentPrunerSuite) TestPruneSegmentsVariousIntTypes() {
copy(testSegments, sealedSegments)
exprStr := "int16 > 2550"
schemaHelper, _ := typeutil.CreateSchemaHelper(schema)
planNode, err := planparserv2.CreateRetrievePlan(schemaHelper, exprStr)
planNode, err := planparserv2.CreateRetrievePlan(schemaHelper, exprStr, nil)
sps.NoError(err)
serializedPlan, _ := proto.Marshal(planNode)
queryReq := &internalpb.RetrieveRequest{
@ -1063,7 +1063,7 @@ func (sps *SegmentPrunerSuite) TestPruneSegmentsVariousIntTypes() {
copy(testSegments, sealedSegments)
exprStr := "int32 > 2147483648"
schemaHelper, _ := typeutil.CreateSchemaHelper(schema)
planNode, err := planparserv2.CreateRetrievePlan(schemaHelper, exprStr)
planNode, err := planparserv2.CreateRetrievePlan(schemaHelper, exprStr, nil)
sps.NoError(err)
serializedPlan, _ := proto.Marshal(planNode)
queryReq := &internalpb.RetrieveRequest{
@ -1079,7 +1079,7 @@ func (sps *SegmentPrunerSuite) TestPruneSegmentsVariousIntTypes() {
copy(testSegments, sealedSegments)
exprStr := "int32 < -2147483649"
schemaHelper, _ := typeutil.CreateSchemaHelper(schema)
planNode, err := planparserv2.CreateRetrievePlan(schemaHelper, exprStr)
planNode, err := planparserv2.CreateRetrievePlan(schemaHelper, exprStr, nil)
sps.NoError(err)
serializedPlan, _ := proto.Marshal(planNode)
queryReq := &internalpb.RetrieveRequest{
@ -1095,7 +1095,7 @@ func (sps *SegmentPrunerSuite) TestPruneSegmentsVariousIntTypes() {
copy(testSegments, sealedSegments)
exprStr := "int32 > 12550"
schemaHelper, _ := typeutil.CreateSchemaHelper(schema)
planNode, err := planparserv2.CreateRetrievePlan(schemaHelper, exprStr)
planNode, err := planparserv2.CreateRetrievePlan(schemaHelper, exprStr, nil)
sps.NoError(err)
serializedPlan, _ := proto.Marshal(planNode)
queryReq := &internalpb.RetrieveRequest{
@ -1230,7 +1230,7 @@ func (sps *SegmentPrunerSuite) TestPruneSegmentsFloatTypes() {
copy(testSegments, sealedSegments)
exprStr := "float > 3.5"
schemaHelper, _ := typeutil.CreateSchemaHelper(schema)
planNode, err := planparserv2.CreateRetrievePlan(schemaHelper, exprStr)
planNode, err := planparserv2.CreateRetrievePlan(schemaHelper, exprStr, nil)
sps.NoError(err)
serializedPlan, _ := proto.Marshal(planNode)
queryReq := &internalpb.RetrieveRequest{
@ -1347,7 +1347,7 @@ func (sps *SegmentPrunerSuite) TestPruneSegmentsFloatTypes() {
copy(testSegments, sealedSegments)
exprStr := "double < -1.5"
schemaHelper, _ := typeutil.CreateSchemaHelper(schema)
planNode, err := planparserv2.CreateRetrievePlan(schemaHelper, exprStr)
planNode, err := planparserv2.CreateRetrievePlan(schemaHelper, exprStr, nil)
sps.NoError(err)
serializedPlan, _ := proto.Marshal(planNode)
queryReq := &internalpb.RetrieveRequest{
@ -1421,7 +1421,7 @@ func (sps *SegmentPrunerSuite) TestPruneSegmentsWithoutPartitionStats() {
copy(testSegments, sealedSegments)
exprStr := "double < -1.5"
schemaHelper, _ := typeutil.CreateSchemaHelper(schema)
planNode, err := planparserv2.CreateRetrievePlan(schemaHelper, exprStr)
planNode, err := planparserv2.CreateRetrievePlan(schemaHelper, exprStr, nil)
sps.NoError(err)
serializedPlan, _ := proto.Marshal(planNode)
queryReq := &internalpb.RetrieveRequest{
@ -1441,7 +1441,7 @@ func (sps *SegmentPrunerSuite) TestPruneSegmentsWithoutPartitionStats() {
copy(testSegments, sealedSegments)
exprStr := "double < -1.5"
schemaHelper, _ := typeutil.CreateSchemaHelper(schema)
planNode, err := planparserv2.CreateRetrievePlan(schemaHelper, exprStr)
planNode, err := planparserv2.CreateRetrievePlan(schemaHelper, exprStr, nil)
sps.NoError(err)
serializedPlan, _ := proto.Marshal(planNode)
queryReq := &internalpb.RetrieveRequest{
@ -1459,7 +1459,7 @@ func (sps *SegmentPrunerSuite) TestPruneSegmentsWithoutPartitionStats() {
copy(testSegments, sealedSegments)
exprStr := "double < -1.5"
schemaHelper, _ := typeutil.CreateSchemaHelper(schema)
planNode, err := planparserv2.CreateRetrievePlan(schemaHelper, exprStr)
planNode, err := planparserv2.CreateRetrievePlan(schemaHelper, exprStr, nil)
sps.NoError(err)
serializedPlan, _ := proto.Marshal(planNode)
queryReq := &internalpb.RetrieveRequest{
@ -1537,7 +1537,7 @@ func (sps *SegmentPrunerSuite) TestPruneSegmentsWithoutPartitionStats() {
copy(testSegments, sealedSegments)
exprStr := "double < -1.5"
schemaHelper, _ := typeutil.CreateSchemaHelper(schema)
planNode, err := planparserv2.CreateRetrievePlan(schemaHelper, exprStr)
planNode, err := planparserv2.CreateRetrievePlan(schemaHelper, exprStr, nil)
sps.NoError(err)
serializedPlan, _ := proto.Marshal(planNode)
queryReq := &internalpb.RetrieveRequest{

16
internal/util/exprutil/expr_checker_test.go
View File

@ -117,7 +117,7 @@ func TestParsePartitionKeys(t *testing.T) {
for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
// test search plan
searchPlan, err := planparserv2.CreateSearchPlan(schemaHelper, tc.expr, "fvec_field", queryInfo)
searchPlan, err := planparserv2.CreateSearchPlan(schemaHelper, tc.expr, "fvec_field", queryInfo, nil)
assert.NoError(t, err)
expr, err := ParseExprFromPlan(searchPlan)
assert.NoError(t, err)
@ -130,7 +130,7 @@ func TestParsePartitionKeys(t *testing.T) {
}
// test query plan
queryPlan, err := planparserv2.CreateRetrievePlan(schemaHelper, tc.expr)
queryPlan, err := planparserv2.CreateRetrievePlan(schemaHelper, tc.expr, nil)
assert.NoError(t, err)
expr, err = ParseExprFromPlan(queryPlan)
assert.NoError(t, err)
@ -173,7 +173,7 @@ func TestParseIntRanges(t *testing.T) {
// test query plan
{
expr := "cluster_key_field > 50"
queryPlan, err := planparserv2.CreateRetrievePlan(schemaHelper, expr)
queryPlan, err := planparserv2.CreateRetrievePlan(schemaHelper, expr, nil)
assert.NoError(t, err)
planExpr, err := ParseExprFromPlan(queryPlan)
assert.NoError(t, err)
@ -190,7 +190,7 @@ func TestParseIntRanges(t *testing.T) {
// test binary query plan
{
expr := "cluster_key_field > 50 and cluster_key_field <= 100"
queryPlan, err := planparserv2.CreateRetrievePlan(schemaHelper, expr)
queryPlan, err := planparserv2.CreateRetrievePlan(schemaHelper, expr, nil)
assert.NoError(t, err)
planExpr, err := ParseExprFromPlan(queryPlan)
assert.NoError(t, err)
@ -206,7 +206,7 @@ func TestParseIntRanges(t *testing.T) {
// test binary query plan
{
expr := "cluster_key_field >= 50 and cluster_key_field < 100"
queryPlan, err := planparserv2.CreateRetrievePlan(schemaHelper, expr)
queryPlan, err := planparserv2.CreateRetrievePlan(schemaHelper, expr, nil)
assert.NoError(t, err)
planExpr, err := ParseExprFromPlan(queryPlan)
assert.NoError(t, err)
@ -222,7 +222,7 @@ func TestParseIntRanges(t *testing.T) {
// test binary query plan
{
expr := "cluster_key_field in [100]"
queryPlan, err := planparserv2.CreateRetrievePlan(schemaHelper, expr)
queryPlan, err := planparserv2.CreateRetrievePlan(schemaHelper, expr, nil)
assert.NoError(t, err)
planExpr, err := ParseExprFromPlan(queryPlan)
assert.NoError(t, err)
@ -264,7 +264,7 @@ func TestParseStrRanges(t *testing.T) {
// test query plan
{
expr := "cluster_key_field >= \"aaa\""
queryPlan, err := planparserv2.CreateRetrievePlan(schemaHelper, expr)
queryPlan, err := planparserv2.CreateRetrievePlan(schemaHelper, expr, nil)
assert.NoError(t, err)
planExpr, err := ParseExprFromPlan(queryPlan)
assert.NoError(t, err)
@ -477,7 +477,7 @@ func TestValidatePartitionKeyIsolation(t *testing.T) {
for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
queryPlan, err := planparserv2.CreateRetrievePlan(schemaHelper, tc.expr)
queryPlan, err := planparserv2.CreateRetrievePlan(schemaHelper, tc.expr, nil)
assert.NoError(t, err)
planExpr, err := ParseExprFromPlan(queryPlan)
assert.NoError(t, err)