Support json contains feature (#25384)

Signed-off-by: cai.zhang <cai.zhang@zilliz.com>

internal/core/src/common/Types.h

@@ -83,6 +83,7 @@ using VectorArray = proto::schema::VectorField;
 using IdArray = proto::schema::IDs;
 using InsertData = proto::segcore::InsertRecord;
 using PkType = std::variant<std::monostate, int64_t, std::string>;
+using ContainsType = proto::plan::JSONContainsExpr_JSONOp;
 
 inline bool
 IsPrimaryKeyDataType(DataType data_type) {

internal/core/src/query/Expr.h

@@ -279,6 +279,30 @@ CreateAlwaysTrueExpr() {
     return std::make_unique<AlwaysTrueExpr>();
 }
 
+struct JsonContainsExpr : Expr {
+    const ColumnInfo column_;
+    bool same_type_;
+    ContainsType op_;
+    const proto::plan::GenericValue::ValCase val_case_;
+
+ protected:
+    JsonContainsExpr() = delete;
+
+    JsonContainsExpr(ColumnInfo column,
+                     const bool same_type,
+                     ContainsType op,
+                     proto::plan::GenericValue::ValCase val_case)
+        : column_(std::move(column)),
+          same_type_(same_type),
+          op_(op),
+          val_case_(val_case) {
+    }
+
+ public:
+    void
+    accept(ExprVisitor&) override;
+};
+
 inline bool
 IsTermExpr(Expr* expr) {
     TermExpr* term_expr = dynamic_cast<TermExpr*>(expr);

internal/core/src/query/ExprImpl.h

@@ -97,4 +97,19 @@ struct ExistsExprImpl : ExistsExpr {
     }
 };
 
+template <typename T>
+struct JsonContainsExprImpl : JsonContainsExpr {
+    const std::vector<T> elements_;
+
+    JsonContainsExprImpl(ColumnInfo column,
+                         std::vector<T> elements,
+                         const bool same_type,
+                         ContainsType op,
+                         proto::plan::GenericValue::ValCase val_case)
+        : JsonContainsExpr(
+              std::forward<ColumnInfo>(column), same_type, op, val_case),
+          elements_(std::move(elements)) {
+    }
+};
+
 }  // namespace milvus::query

internal/core/src/query/PlanProto.cpp

@@ -579,6 +579,91 @@ ProtoParser::ParseExistExpr(const proto::plan::ExistsExpr& expr_pb) {
     return result;
 }
 
+template <typename T>
+std::unique_ptr<JsonContainsExprImpl<T>>
+ExtractJsonContainsExprImpl(const proto::plan::JSONContainsExpr& expr_proto) {
+    static_assert(IsScalar<T> or std::is_same_v<T, proto::plan::GenericValue> or
+                  std::is_same_v<T, proto::plan::Array>);
+    auto size = expr_proto.elements_size();
+    std::vector<T> terms;
+    terms.reserve(size);
+    auto val_case = proto::plan::GenericValue::VAL_NOT_SET;
+    for (int i = 0; i < size; ++i) {
+        auto& value_proto = expr_proto.elements(i);
+        if constexpr (std::is_same_v<T, bool>) {
+            Assert(value_proto.val_case() == planpb::GenericValue::kBoolVal);
+            terms.push_back(static_cast<T>(value_proto.bool_val()));
+            val_case = proto::plan::GenericValue::ValCase::kBoolVal;
+        } else if constexpr (std::is_integral_v<T>) {
+            Assert(value_proto.val_case() == planpb::GenericValue::kInt64Val);
+            auto value = value_proto.int64_val();
+            if (out_of_range<T>(value)) {
+                continue;
+            }
+            terms.push_back(static_cast<T>(value));
+            val_case = proto::plan::GenericValue::ValCase::kInt64Val;
+        } else if constexpr (std::is_floating_point_v<T>) {
+            Assert(value_proto.val_case() == planpb::GenericValue::kFloatVal);
+            terms.push_back(static_cast<T>(value_proto.float_val()));
+            val_case = proto::plan::GenericValue::ValCase::kFloatVal;
+        } else if constexpr (std::is_same_v<T, std::string>) {
+            Assert(value_proto.val_case() == planpb::GenericValue::kStringVal);
+            terms.push_back(static_cast<T>(value_proto.string_val()));
+            val_case = proto::plan::GenericValue::ValCase::kStringVal;
+        } else if constexpr (std::is_same_v<T, proto::plan::Array>) {
+            Assert(value_proto.val_case() == planpb::GenericValue::kArrayVal);
+            terms.push_back(static_cast<T>(value_proto.array_val()));
+            val_case = proto::plan::GenericValue::ValCase::kArrayVal;
+        } else if constexpr (std::is_same_v<T, proto::plan::GenericValue>) {
+            terms.push_back(value_proto);
+        } else {
+            static_assert(always_false<T>);
+        }
+    }
+
+    return std::make_unique<JsonContainsExprImpl<T>>(
+        expr_proto.column_info(),
+        terms,
+        expr_proto.elements_same_type(),
+        expr_proto.op(),
+        val_case);
+}
+
+ExprPtr
+ProtoParser::ParseJsonContainsExpr(
+    const proto::plan::JSONContainsExpr& expr_pb) {
+    auto& columnInfo = expr_pb.column_info();
+    auto field_id = FieldId(columnInfo.field_id());
+    auto data_type = schema[field_id].get_data_type();
+    Assert(data_type == (DataType)columnInfo.data_type());
+
+    // auto& field_meta = schema[field_offset];
+    auto result = [&]() -> ExprPtr {
+        if (expr_pb.elements_size() == 0) {
+            PanicInfo("no elements in expression");
+        }
+        if (expr_pb.elements_same_type()) {
+            switch (expr_pb.elements(0).val_case()) {
+                case proto::plan::GenericValue::kBoolVal:
+                    return ExtractJsonContainsExprImpl<bool>(expr_pb);
+                case proto::plan::GenericValue::kInt64Val:
+                    return ExtractJsonContainsExprImpl<int64_t>(expr_pb);
+                case proto::plan::GenericValue::kFloatVal:
+                    return ExtractJsonContainsExprImpl<double>(expr_pb);
+                case proto::plan::GenericValue::kStringVal:
+                    return ExtractJsonContainsExprImpl<std::string>(expr_pb);
+                case proto::plan::GenericValue::kArrayVal:
+                    return ExtractJsonContainsExprImpl<proto::plan::Array>(
+                        expr_pb);
+                default:
+                    PanicInfo("unsupported data type");
+            }
+        }
+        return ExtractJsonContainsExprImpl<proto::plan::GenericValue>(expr_pb);
+    }();
+    return result;
+}
+
 ExprPtr
 ProtoParser::ParseExpr(const proto::plan::Expr& expr_pb) {
     using ppe = proto::plan::Expr;
@@ -611,6 +696,9 @@ ProtoParser::ParseExpr(const proto::plan::Expr& expr_pb) {
         case ppe::kAlwaysTrueExpr: {
             return CreateAlwaysTrueExpr();
         }
+        case ppe::kJsonContainsExpr: {
+            return ParseJsonContainsExpr(expr_pb.json_contains_expr());
+        }
         default:
             PanicInfo("unsupported expr proto node");
     }

internal/core/src/query/PlanProto.h

@@ -54,6 +54,9 @@ class ProtoParser {
     ExprPtr
     ParseExistExpr(const proto::plan::ExistsExpr& expr_pb);
 
+    ExprPtr
+    ParseJsonContainsExpr(const proto::plan::JSONContainsExpr& expr_pb);
+
     ExprPtr
     ParseExpr(const proto::plan::Expr& expr_pb);
 

internal/core/src/query/generated/ExecExprVisitor.h

@@ -56,6 +56,9 @@ class ExecExprVisitor : public ExprVisitor {
     void
     visit(AlwaysTrueExpr& expr) override;
 
+    void
+    visit(JsonContainsExpr& expr) override;
+
  public:
     ExecExprVisitor(const segcore::SegmentInternalInterface& segment,
                     int64_t row_count,
@@ -155,6 +158,26 @@ class ExecExprVisitor : public ExprVisitor {
     ExecCompareExprDispatcher(CompareExpr& expr, CmpFunc cmp_func)
         -> BitsetType;
 
+    template <typename ExprValueType>
+    auto
+    ExecJsonContains(JsonContainsExpr& expr_raw) -> BitsetType;
+
+    auto
+    ExecJsonContainsArray(JsonContainsExpr& expr_raw) -> BitsetType;
+
+    auto
+    ExecJsonContainsWithDiffType(JsonContainsExpr& expr_raw) -> BitsetType;
+
+    template <typename ExprValueType>
+    auto
+    ExecJsonContainsAll(JsonContainsExpr& expr_raw) -> BitsetType;
+
+    auto
+    ExecJsonContainsAllArray(JsonContainsExpr& expr_raw) -> BitsetType;
+
+    auto
+    ExecJsonContainsAllWithDiffType(JsonContainsExpr& expr_raw) -> BitsetType;
+
     template <typename CmpFunc>
     BitsetType
     ExecCompareExprDispatcherForNonIndexedSegment(CompareExpr& expr,

internal/core/src/query/generated/Expr.cpp

@@ -58,4 +58,9 @@ void
 AlwaysTrueExpr::accept(ExprVisitor& visitor) {
     visitor.visit(*this);
 }
+
+void
+JsonContainsExpr::accept(ExprVisitor& visitor) {
+    visitor.visit(*this);
+}
 }  // namespace milvus::query

internal/core/src/query/generated/ExprVisitor.h

@@ -45,5 +45,8 @@ class ExprVisitor {
 
     virtual void
     visit(AlwaysTrueExpr&) = 0;
+
+    virtual void
+    visit(JsonContainsExpr&) = 0;
 };
 }  // namespace milvus::query

internal/core/src/query/generated/ExtractInfoExprVisitor.h

@@ -45,6 +45,9 @@ class ExtractInfoExprVisitor : public ExprVisitor {
     void
     visit(AlwaysTrueExpr& expr) override;
 
+    void
+    visit(JsonContainsExpr& expr) override;
+
  public:
     explicit ExtractInfoExprVisitor(ExtractedPlanInfo& plan_info)
         : plan_info_(plan_info) {

internal/core/src/query/generated/ShowExprVisitor.h

@@ -46,6 +46,9 @@ class ShowExprVisitor : public ExprVisitor {
     void
     visit(AlwaysTrueExpr& expr) override;
 
+    void
+    visit(JsonContainsExpr& expr) override;
+
  public:
     Json
 

internal/core/src/query/generated/VerifyExprVisitor.h

@@ -50,6 +50,9 @@ class VerifyExprVisitor : public ExprVisitor {
     void
     visit(AlwaysTrueExpr& expr) override;
 
+    void
+    visit(JsonContainsExpr& expr) override;
+
  public:
 };
 }  // namespace milvus::query

internal/core/src/query/visitors/ExecExprVisitor.cpp

@@ -1934,8 +1934,9 @@ ExecExprVisitor::ExecTermJsonVariableInField(TermExpr& expr_raw) -> BitsetType {
             if (val.error()) {
                 return false;
             }
-            if (val.value() == target_val)
+            if (val.value() == target_val) {
                 return true;
+            }
         }
         return false;
     };
@@ -2066,4 +2067,469 @@ ExecExprVisitor::visit(AlwaysTrueExpr& expr) {
     bitset_opt_ = std::move(res);
 }
 
+bool
+compareTwoJsonArray(
+    simdjson::simdjson_result<simdjson::fallback::ondemand::array> arr1,
+    const proto::plan::Array& arr2) {
+    if (arr2.array_size() != arr1.count_elements()) {
+        return false;
+    }
+    int i = 0;
+    for (auto&& it : arr1) {
+        switch (arr2.array(i).val_case()) {
+            case proto::plan::GenericValue::kBoolVal: {
+                auto val = it.template get<bool>();
+                if (val.error() || val.value() != arr2.array(i).bool_val()) {
+                    return false;
+                }
+                break;
+            }
+            case proto::plan::GenericValue::kInt64Val: {
+                auto val = it.template get<int64_t>();
+                if (val.error() || val.value() != arr2.array(i).int64_val()) {
+                    return false;
+                }
+                break;
+            }
+            case proto::plan::GenericValue::kFloatVal: {
+                auto val = it.template get<double>();
+                if (val.error() || val.value() != arr2.array(i).float_val()) {
+                    return false;
+                }
+                break;
+            }
+            case proto::plan::GenericValue::kStringVal: {
+                auto val = it.template get<std::string_view>();
+                if (val.error() || val.value() != arr2.array(i).string_val()) {
+                    return false;
+                }
+                break;
+            }
+            default:
+                PanicInfo(fmt::format("unsupported data type {}",
+                                      arr2.array(i).val_case()));
+        }
+        i++;
+    }
+    return true;
+}
+
+template <typename ExprValueType>
+auto
+ExecExprVisitor::ExecJsonContains(JsonContainsExpr& expr_raw) -> BitsetType {
+    using Index = index::ScalarIndex<milvus::Json>;
+    auto& expr = static_cast<JsonContainsExprImpl<ExprValueType>&>(expr_raw);
+    auto pointer = milvus::Json::pointer(expr.column_.nested_path);
+    auto index_func = [](Index* index) { return TargetBitmap{}; };
+    using GetType =
+        std::conditional_t<std::is_same_v<ExprValueType, std::string>,
+                           std::string_view,
+                           ExprValueType>;
+    std::unordered_set<GetType> elements;
+    for (auto const& element : expr.elements_) {
+        elements.insert(element);
+    }
+    auto elem_func = [&elements, &pointer](const milvus::Json& json) {
+        auto doc = json.doc();
+        auto array = doc.at_pointer(pointer).get_array();
+        if (array.error()) {
+            return false;
+        }
+        for (auto&& it : array) {
+            auto val = it.template get<GetType>();
+            if (val.error()) {
+                continue;
+            }
+            if (elements.count(val.value()) > 0) {
+                return true;
+            }
+        }
+        return false;
+    };
+
+    return ExecRangeVisitorImpl<milvus::Json>(
+        expr.column_.field_id, index_func, elem_func);
+}
+
+auto
+ExecExprVisitor::ExecJsonContainsArray(JsonContainsExpr& expr_raw)
+    -> BitsetType {
+    using Index = index::ScalarIndex<milvus::Json>;
+    auto& expr =
+        static_cast<JsonContainsExprImpl<proto::plan::Array>&>(expr_raw);
+    auto pointer = milvus::Json::pointer(expr.column_.nested_path);
+    auto index_func = [](Index* index) { return TargetBitmap{}; };
+    auto& elements = expr.elements_;
+    auto elem_func = [&elements, &pointer](const milvus::Json& json) {
+        auto doc = json.doc();
+        auto array = doc.at_pointer(pointer).get_array();
+        if (array.error()) {
+            return false;
+        }
+        for (auto const& element : elements) {
+            for (auto&& it : array) {
+                auto val = it.get_array();
+                if (val.error()) {
+                    continue;
+                }
+                if (compareTwoJsonArray(val, element)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    };
+
+    return ExecRangeVisitorImpl<milvus::Json>(
+        expr.column_.field_id, index_func, elem_func);
+}
+
+auto
+ExecExprVisitor::ExecJsonContainsWithDiffType(JsonContainsExpr& expr_raw)
+    -> BitsetType {
+    using Index = index::ScalarIndex<milvus::Json>;
+    auto& expr =
+        static_cast<JsonContainsExprImpl<proto::plan::GenericValue>&>(expr_raw);
+    auto pointer = milvus::Json::pointer(expr.column_.nested_path);
+    auto index_func = [](Index* index) { return TargetBitmap{}; };
+    auto& elements = expr.elements_;
+    auto elem_func = [&elements, &pointer](const milvus::Json& json) {
+        auto doc = json.doc();
+        auto array = doc.at_pointer(pointer).get_array();
+        if (array.error()) {
+            return false;
+        }
+        // Note: array can only be iterated once
+        for (auto&& it : array) {
+            for (auto const& element : elements) {
+                switch (element.val_case()) {
+                    case proto::plan::GenericValue::kBoolVal: {
+                        auto val = it.template get<bool>();
+                        if (val.error()) {
+                            continue;
+                        }
+                        if (val.value() == element.bool_val()) {
+                            return true;
+                        }
+                        break;
+                    }
+                    case proto::plan::GenericValue::kInt64Val: {
+                        auto val = it.template get<int64_t>();
+                        if (val.error()) {
+                            continue;
+                        }
+                        if (val.value() == element.int64_val()) {
+                            return true;
+                        }
+                        break;
+                    }
+                    case proto::plan::GenericValue::kFloatVal: {
+                        auto val = it.template get<double>();
+                        if (val.error()) {
+                            continue;
+                        }
+                        if (val.value() == element.float_val()) {
+                            return true;
+                        }
+                        break;
+                    }
+                    case proto::plan::GenericValue::kStringVal: {
+                        auto val = it.template get<std::string_view>();
+                        if (val.error()) {
+                            continue;
+                        }
+                        if (val.value() == element.string_val()) {
+                            return true;
+                        }
+                        break;
+                    }
+                    case proto::plan::GenericValue::kArrayVal: {
+                        auto val = it.get_array();
+                        if (val.error()) {
+                            continue;
+                        }
+                        if (compareTwoJsonArray(val, element.array_val())) {
+                            return true;
+                        }
+                        break;
+                    }
+                    default:
+                        PanicInfo(fmt::format("unsupported data type {}",
+                                              element.val_case()));
+                }
+            }
+        }
+        return false;
+    };
+
+    return ExecRangeVisitorImpl<milvus::Json>(
+        expr.column_.field_id, index_func, elem_func);
+}
+
+template <typename ExprValueType>
+auto
+ExecExprVisitor::ExecJsonContainsAll(JsonContainsExpr& expr_raw) -> BitsetType {
+    using Index = index::ScalarIndex<milvus::Json>;
+    auto& expr = static_cast<JsonContainsExprImpl<ExprValueType>&>(expr_raw);
+    auto pointer = milvus::Json::pointer(expr.column_.nested_path);
+    auto index_func = [](Index* index) { return TargetBitmap{}; };
+    using GetType =
+        std::conditional_t<std::is_same_v<ExprValueType, std::string>,
+                           std::string_view,
+                           ExprValueType>;
+
+    std::unordered_set<GetType> elements;
+    for (auto const& element : expr.elements_) {
+        elements.insert(element);
+    }
+    //    auto elements = expr.elements_;
+    auto elem_func = [&elements, &pointer](const milvus::Json& json) {
+        auto doc = json.doc();
+        auto array = doc.at_pointer(pointer).get_array();
+        if (array.error()) {
+            return false;
+        }
+        std::unordered_set<GetType> tmp_elements(elements);
+        // Note: array can only be iterated once
+        for (auto&& it : array) {
+            auto val = it.template get<GetType>();
+            if (val.error()) {
+                continue;
+            }
+            tmp_elements.erase(val.value());
+            if (tmp_elements.size() == 0) {
+                return true;
+            }
+        }
+        return tmp_elements.size() == 0;
+    };
+
+    return ExecRangeVisitorImpl<milvus::Json>(
+        expr.column_.field_id, index_func, elem_func);
+}
+
+auto
+ExecExprVisitor::ExecJsonContainsAllArray(JsonContainsExpr& expr_raw)
+    -> BitsetType {
+    using Index = index::ScalarIndex<milvus::Json>;
+    auto& expr =
+        static_cast<JsonContainsExprImpl<proto::plan::Array>&>(expr_raw);
+    auto pointer = milvus::Json::pointer(expr.column_.nested_path);
+    auto index_func = [](Index* index) { return TargetBitmap{}; };
+    auto& elements = expr.elements_;
+    std::unordered_set<int> elements_index;
+    int i = 0;
+    for (auto& element : expr.elements_) {
+        elements_index.insert(i);
+        i++;
+    }
+    auto elem_func =
+        [&elements, &elements_index, &pointer](const milvus::Json& json) {
+            auto doc = json.doc();
+            auto array = doc.at_pointer(pointer).get_array();
+            if (array.error()) {
+                return false;
+            }
+            std::unordered_set<int> tmp_elements_index(elements_index);
+            for (auto&& it : array) {
+                auto val = it.get_array();
+                if (val.error()) {
+                    continue;
+                }
+                int i = -1;
+                for (auto const& element : elements) {
+                    i++;
+                    if (compareTwoJsonArray(val, element)) {
+                        tmp_elements_index.erase(i);
+                        break;
+                    }
+                }
+                if (tmp_elements_index.size() == 0) {
+                    return true;
+                }
+            }
+            return tmp_elements_index.size() == 0;
+        };
+
+    return ExecRangeVisitorImpl<milvus::Json>(
+        expr.column_.field_id, index_func, elem_func);
+}
+
+auto
+ExecExprVisitor::ExecJsonContainsAllWithDiffType(JsonContainsExpr& expr_raw)
+    -> BitsetType {
+    using Index = index::ScalarIndex<milvus::Json>;
+    auto& expr =
+        static_cast<JsonContainsExprImpl<proto::plan::GenericValue>&>(expr_raw);
+    auto pointer = milvus::Json::pointer(expr.column_.nested_path);
+    auto index_func = [](Index* index) { return TargetBitmap{}; };
+
+    auto elements = expr.elements_;
+    std::unordered_set<int> elements_index;
+    int i = 0;
+    for (auto& element : expr.elements_) {
+        elements_index.insert(i);
+        i++;
+    }
+    auto elem_func =
+        [&elements, &elements_index, &pointer](const milvus::Json& json) {
+            auto doc = json.doc();
+            auto array = doc.at_pointer(pointer).get_array();
+            if (array.error()) {
+                return false;
+            }
+            std::unordered_set<int> tmp_elements_index(elements_index);
+            for (auto&& it : array) {
+                int i = -1;
+                for (auto& element : elements) {
+                    i++;
+                    switch (element.val_case()) {
+                        case proto::plan::GenericValue::kBoolVal: {
+                            auto val = it.template get<bool>();
+                            if (val.error()) {
+                                continue;
+                            }
+                            if (val.value() == element.bool_val()) {
+                                tmp_elements_index.erase(i);
+                            }
+                            break;
+                        }
+                        case proto::plan::GenericValue::kInt64Val: {
+                            auto val = it.template get<int64_t>();
+                            if (val.error()) {
+                                continue;
+                            }
+                            if (val.value() == element.int64_val()) {
+                                tmp_elements_index.erase(i);
+                            }
+                            break;
+                        }
+                        case proto::plan::GenericValue::kFloatVal: {
+                            auto val = it.template get<double>();
+                            if (val.error()) {
+                                continue;
+                            }
+                            if (val.value() == element.float_val()) {
+                                tmp_elements_index.erase(i);
+                            }
+                            break;
+                        }
+                        case proto::plan::GenericValue::kStringVal: {
+                            auto val = it.template get<std::string_view>();
+                            if (val.error()) {
+                                continue;
+                            }
+                            if (val.value() == element.string_val()) {
+                                tmp_elements_index.erase(i);
+                            }
+                            break;
+                        }
+                        case proto::plan::GenericValue::kArrayVal: {
+                            auto val = it.get_array();
+                            if (val.error()) {
+                                continue;
+                            }
+                            if (compareTwoJsonArray(val, element.array_val())) {
+                                tmp_elements_index.erase(i);
+                            }
+                            break;
+                        }
+                        default:
+                            PanicInfo(fmt::format("unsupported data type {}",
+                                                  element.val_case()));
+                    }
+                    if (tmp_elements_index.size() == 0) {
+                        return true;
+                    }
+                }
+                if (tmp_elements_index.size() == 0) {
+                    return true;
+                }
+            }
+            return tmp_elements_index.size() == 0;
+        };
+
+    return ExecRangeVisitorImpl<milvus::Json>(
+        expr.column_.field_id, index_func, elem_func);
+}
+
+void
+ExecExprVisitor::visit(JsonContainsExpr& expr) {
+    auto& field_meta = segment_.get_schema()[expr.column_.field_id];
+    AssertInfo(
+        expr.column_.data_type == DataType::JSON,
+        "[ExecExprVisitor]DataType of JsonContainsExpr isn't json data type");
+    BitsetType res;
+    switch (expr.op_) {
+        case proto::plan::JSONContainsExpr_JSONOp_Contains:
+        case proto::plan::JSONContainsExpr_JSONOp_ContainsAny: {
+            if (expr.same_type_) {
+                switch (expr.val_case_) {
+                    case proto::plan::GenericValue::kBoolVal: {
+                        res = ExecJsonContains<bool>(expr);
+                        break;
+                    }
+                    case proto::plan::GenericValue::kInt64Val: {
+                        res = ExecJsonContains<int64_t>(expr);
+                        break;
+                    }
+                    case proto::plan::GenericValue::kFloatVal: {
+                        res = ExecJsonContains<double>(expr);
+                        break;
+                    }
+                    case proto::plan::GenericValue::kStringVal: {
+                        res = ExecJsonContains<std::string>(expr);
+                        break;
+                    }
+                    case proto::plan::GenericValue::kArrayVal: {
+                        res = ExecJsonContainsArray(expr);
+                        break;
+                    }
+                    default:
+                        PanicInfo(fmt::format("unsupported data type"));
+                }
+                break;
+            }
+            res = ExecJsonContainsWithDiffType(expr);
+            break;
+        }
+        case proto::plan::JSONContainsExpr_JSONOp_ContainsAll: {
+            if (expr.same_type_) {
+                switch (expr.val_case_) {
+                    case proto::plan::GenericValue::kBoolVal: {
+                        res = ExecJsonContainsAll<bool>(expr);
+                        break;
+                    }
+                    case proto::plan::GenericValue::kInt64Val: {
+                        res = ExecJsonContainsAll<int64_t>(expr);
+                        break;
+                    }
+                    case proto::plan::GenericValue::kFloatVal: {
+                        res = ExecJsonContainsAll<double>(expr);
+                        break;
+                    }
+                    case proto::plan::GenericValue::kStringVal: {
+                        res = ExecJsonContainsAll<std::string>(expr);
+                        break;
+                    }
+                    case proto::plan::GenericValue::kArrayVal: {
+                        res = ExecJsonContainsAllArray(expr);
+                        break;
+                    }
+                    default:
+                        PanicInfo(fmt::format("unsupported data type"));
+                }
+                break;
+            }
+            res = ExecJsonContainsAllWithDiffType(expr);
+            break;
+        }
+        default:
+            PanicInfo(fmt::format("unsupported json contains type"));
+    }
+    AssertInfo(res.size() == row_count_,
+               "[ExecExprVisitor]Size of results not equal row count");
+    bitset_opt_ = std::move(res);
+}
+
 }  // namespace milvus::query

internal/core/src/query/visitors/ExtractInfoExprVisitor.cpp

@@ -75,4 +75,9 @@ ExtractInfoExprVisitor::visit(AlwaysTrueExpr& expr) {
     // all is involved.
 }
 
+void
+ExtractInfoExprVisitor::visit(JsonContainsExpr& expr) {
+    plan_info_.add_involved_field(expr.column_.field_id);
+}
+
 }  // namespace milvus::query

internal/core/src/query/visitors/ShowExprVisitor.cpp

@@ -343,4 +343,21 @@ ShowExprVisitor::visit(AlwaysTrueExpr& expr) {
     json_opt_ = res;
 }
 
+void
+ShowExprVisitor::visit(JsonContainsExpr& expr) {
+    using proto::plan::OpType;
+    using proto::plan::OpType_Name;
+    AssertInfo(!json_opt_.has_value(),
+               "[ShowExprVisitor]Ret json already has value before visit");
+
+    Json res{{"expr_type", "JsonContains"},
+             {"field_id", expr.column_.field_id.get()},
+             {"data_type", expr.column_.data_type},
+             {"nested_path", expr.column_.nested_path},
+             {"same_type", expr.same_type_},
+             {"op", expr.op_},
+             {"val_case", expr.val_case_}};
+    json_opt_ = res;
+}
+
 }  // namespace milvus::query

internal/core/src/query/visitors/VerifyExprVisitor.cpp

@@ -57,4 +57,9 @@ VerifyExprVisitor::visit(AlwaysTrueExpr& expr) {
     // TODO
 }
 
+void
+VerifyExprVisitor::visit(JsonContainsExpr& expr) {
+    // TODO
+}
+
 }  // namespace milvus::query

internal/core/unittest/test_expr.cpp

@@ -24,6 +24,7 @@
 #include "query/ExprImpl.h"
 #include "query/Plan.h"
 #include "query/PlanNode.h"
+#include "query/PlanProto.h"
 #include "query/generated/ShowPlanNodeVisitor.h"
 #include "query/generated/ExecExprVisitor.h"
 #include "segcore/SegmentGrowingImpl.h"
@@ -3293,3 +3294,813 @@ TEST(Expr, TestTermInFieldJson) {
         }
     }
 }
+
+TEST(Expr, PraseJsonContainsExpr) {
+    using namespace milvus;
+    using namespace milvus::query;
+    using namespace milvus::segcore;
+
+    std::vector<const char*> raw_plans{
+        R"(vector_anns:<
+            field_id:100
+            predicates:<
+                json_contains_expr:<
+                    column_info:<
+                        field_id:101
+                        data_type:JSON
+                        nested_path:"A"
+                    >
+                    elements:<int64_val:1 > elements:<int64_val:2 > elements:<int64_val:3 >
+                    op:ContainsAny
+                    elements_same_type:true
+                >
+            >
+            query_info:<
+                topk: 10
+                round_decimal: 3
+                metric_type: "L2"
+                search_params: "{\"nprobe\": 10}"
+            > placeholder_tag:"$0"
+        >)",
+        R"(vector_anns:<
+            field_id:100
+            predicates:<
+                json_contains_expr:<
+                    column_info:<
+                        field_id:101
+                        data_type:JSON
+                        nested_path:"A"
+                    >
+                    elements:<int64_val:1 > elements:<int64_val:2 > elements:<int64_val:3 >
+                    op:ContainsAll
+                    elements_same_type:true
+                >
+            >
+            query_info:<
+                topk: 10
+                round_decimal: 3
+                metric_type: "L2"
+                search_params: "{\"nprobe\": 10}"
+            > placeholder_tag:"$0"
+        >)",
+        R"(vector_anns:<
+            field_id:100
+            predicates:<
+                json_contains_expr:<
+                    column_info:<
+                        field_id:101
+                        data_type:JSON
+                        nested_path:"A"
+                    >
+                    elements:<bool_val:true > elements:<bool_val:false > elements:<bool_val:true >
+                    op:ContainsAll
+                    elements_same_type:true
+                >
+            >
+            query_info:<
+                topk: 10
+                round_decimal: 3
+                metric_type: "L2"
+                search_params: "{\"nprobe\": 10}"
+            > placeholder_tag:"$0"
+        >)",
+        R"(vector_anns:<
+            field_id:100
+            predicates:<
+                json_contains_expr:<
+                    column_info:<
+                        field_id:101
+                        data_type:JSON
+                        nested_path:"A"
+                    >
+                    elements:<float_val:1.1 > elements:<float_val:2.2 > elements:<float_val:3.3 >
+                    op:ContainsAll
+                    elements_same_type:true
+                >
+            >
+            query_info:<
+                topk: 10
+                round_decimal: 3
+                metric_type: "L2"
+                search_params: "{\"nprobe\": 10}"
+            > placeholder_tag:"$0"
+        >)",
+        R"(vector_anns:<
+            field_id:100
+            predicates:<
+                json_contains_expr:<
+                    column_info:<
+                        field_id:101
+                        data_type:JSON
+                        nested_path:"A"
+                    >
+                    elements:<string_val:"1" > elements:<string_val:"2" > elements:<string_val:"3" >
+                    op:ContainsAll
+                    elements_same_type:true
+                >
+            >
+            query_info:<
+                topk: 10
+                round_decimal: 3
+                metric_type: "L2"
+                search_params: "{\"nprobe\": 10}"
+            > placeholder_tag:"$0"
+        >)",
+        R"(vector_anns:<
+            field_id:100
+            predicates:<
+                json_contains_expr:<
+                    column_info:<
+                        field_id:101
+                        data_type:JSON
+                        nested_path:"A"
+                    >
+                    elements:<string_val:"1" >
+                    elements:<int64_val:2 >
+                    elements:<float_val:3.3 >
+                    elements:<bool_val:true>
+                    op:ContainsAll
+                >
+            >
+            query_info:<
+                topk: 10
+                round_decimal: 3
+                metric_type: "L2"
+                search_params: "{\"nprobe\": 10}"
+            > placeholder_tag:"$0"
+        >)",
+    };
+
+    for(auto& raw_plan : raw_plans) {
+        auto plan_str = translate_text_plan_to_binary_plan(raw_plan);
+        auto schema = std::make_shared<Schema>();
+        schema->AddDebugField(
+            "fakevec", DataType::VECTOR_FLOAT, 16, knowhere::metric::L2);
+        schema->AddDebugField("json", DataType::JSON);
+        auto plan =
+            CreateSearchPlanByExpr(*schema, plan_str.data(), plan_str.size());
+    }
+}
+
+TEST(Expr, TestJsonContainsAny) {
+    using namespace milvus;
+    using namespace milvus::query;
+    using namespace milvus::segcore;
+
+    auto schema = std::make_shared<Schema>();
+    auto i64_fid = schema->AddDebugField("id", DataType::INT64);
+    auto json_fid = schema->AddDebugField("json", DataType::JSON);
+    schema->set_primary_field_id(i64_fid);
+
+    auto seg = CreateGrowingSegment(schema, empty_index_meta);
+    int N = 10000;
+    std::vector<std::string> json_col;
+    int num_iters = 2;
+    for (int iter = 0; iter < num_iters; ++iter) {
+        auto raw_data = DataGenForJsonArray(schema, N, iter);
+        auto new_json_col = raw_data.get_col<std::string>(json_fid);
+
+        json_col.insert(
+            json_col.end(), new_json_col.begin(), new_json_col.end());
+        seg->PreInsert(N);
+        seg->Insert(iter * N,
+                    N,
+                    raw_data.row_ids_.data(),
+                    raw_data.timestamps_.data(),
+                    raw_data.raw_);
+    }
+
+    auto seg_promote = dynamic_cast<SegmentGrowingImpl*>(seg.get());
+    ExecExprVisitor visitor(
+        *seg_promote, seg_promote->get_row_count(), MAX_TIMESTAMP);
+
+    std::vector<Testcase<bool>> bool_testcases{{{true}, {"bool"}},
+                                               {{false}, {"bool"}}};
+
+    for (auto testcase : bool_testcases) {
+        auto check = [&](const std::vector<bool>& values) {
+            return std::find(values.begin(), values.end(), testcase.term[0]) !=
+                   values.end();
+        };
+        RetrievePlanNode plan;
+        auto pointer = milvus::Json::pointer(testcase.nested_path);
+        plan.predicate_ = std::make_unique<JsonContainsExprImpl<bool>>(
+            ColumnInfo(json_fid, DataType::JSON, testcase.nested_path),
+            testcase.term,
+            true,
+            proto::plan::JSONContainsExpr_JSONOp_ContainsAny,
+            proto::plan::GenericValue::ValCase::kBoolVal);
+        auto start = std::chrono::steady_clock::now();
+        auto final = visitor.call_child(*plan.predicate_.value());
+        std::cout << "cost"
+                  << std::chrono::duration_cast<std::chrono::microseconds>(
+                         std::chrono::steady_clock::now() - start)
+                         .count()
+                  << std::endl;
+        EXPECT_EQ(final.size(), N * num_iters);
+
+        for (int i = 0; i < N * num_iters; ++i) {
+            auto ans = final[i];
+            auto array = milvus::Json(simdjson::padded_string(json_col[i]))
+                             .array_at(pointer);
+            std::vector<bool> res;
+            for (const auto& element : array) {
+                res.push_back(element.template get<bool>());
+            }
+            ASSERT_EQ(ans, check(res));
+        }
+    }
+
+    std::vector<Testcase<double>> double_testcases{
+        {{1.123}, {"double"}},
+        {{10.34}, {"double"}},
+        {{100.234}, {"double"}},
+        {{1000.4546}, {"double"}},
+    };
+
+    for (auto testcase : double_testcases) {
+        auto check = [&](const std::vector<double>& values) {
+            return std::find(values.begin(), values.end(), testcase.term[0]) !=
+                   values.end();
+        };
+        RetrievePlanNode plan;
+        auto pointer = milvus::Json::pointer(testcase.nested_path);
+        plan.predicate_ = std::make_unique<JsonContainsExprImpl<double>>(
+            ColumnInfo(json_fid, DataType::JSON, testcase.nested_path),
+            testcase.term,
+            true,
+            proto::plan::JSONContainsExpr_JSONOp_ContainsAny,
+            proto::plan::GenericValue::ValCase::kFloatVal);
+        auto start = std::chrono::steady_clock::now();
+        auto final = visitor.call_child(*plan.predicate_.value());
+        std::cout << "cost"
+                  << std::chrono::duration_cast<std::chrono::microseconds>(
+                         std::chrono::steady_clock::now() - start)
+                         .count()
+                  << std::endl;
+        EXPECT_EQ(final.size(), N * num_iters);
+
+        for (int i = 0; i < N * num_iters; ++i) {
+            auto ans = final[i];
+            auto array = milvus::Json(simdjson::padded_string(json_col[i]))
+                             .array_at(pointer);
+            std::vector<double> res;
+            for (const auto& element : array) {
+                res.push_back(element.template get<double>());
+            }
+            ASSERT_EQ(ans, check(res));
+        }
+    }
+
+    std::vector<Testcase<int64_t>> testcases{
+        {{1}, {"int"}},
+        {{10}, {"int"}},
+        {{100}, {"int"}},
+        {{1000}, {"int"}},
+    };
+
+    for (auto testcase : testcases) {
+        auto check = [&](const std::vector<int64_t>& values) {
+            return std::find(values.begin(), values.end(), testcase.term[0]) !=
+                   values.end();
+        };
+        RetrievePlanNode plan;
+        auto pointer = milvus::Json::pointer(testcase.nested_path);
+        plan.predicate_ = std::make_unique<JsonContainsExprImpl<int64_t>>(
+            ColumnInfo(json_fid, DataType::JSON, testcase.nested_path),
+            testcase.term,
+            true,
+            proto::plan::JSONContainsExpr_JSONOp_ContainsAny,
+            proto::plan::GenericValue::ValCase::kInt64Val);
+        auto start = std::chrono::steady_clock::now();
+        auto final = visitor.call_child(*plan.predicate_.value());
+        std::cout << "cost"
+                  << std::chrono::duration_cast<std::chrono::microseconds>(
+                         std::chrono::steady_clock::now() - start)
+                         .count()
+                  << std::endl;
+        EXPECT_EQ(final.size(), N * num_iters);
+
+        for (int i = 0; i < N * num_iters; ++i) {
+            auto ans = final[i];
+            auto array = milvus::Json(simdjson::padded_string(json_col[i]))
+                             .array_at(pointer);
+            std::vector<int64_t> res;
+            for (const auto& element : array) {
+                res.push_back(element.template get<int64_t>());
+            }
+            ASSERT_EQ(ans, check(res));
+        }
+    }
+
+    std::vector<Testcase<std::string>> testcases_string = {
+        {{"1sads"}, {"string"}},
+        {{"10dsf"}, {"string"}},
+        {{"100"}, {"string"}},
+        {{"100ddfdsssdfdsfsd0"}, {"string"}},
+    };
+
+    for (auto testcase : testcases_string) {
+        auto check = [&](const std::vector<std::string_view>& values) {
+            return std::find(values.begin(), values.end(), testcase.term[0]) !=
+                   values.end();
+        };
+        RetrievePlanNode plan;
+        auto pointer = milvus::Json::pointer(testcase.nested_path);
+        plan.predicate_ = std::make_unique<JsonContainsExprImpl<std::string>>(
+            ColumnInfo(json_fid, DataType::JSON, testcase.nested_path),
+            testcase.term,
+            true,
+            proto::plan::JSONContainsExpr_JSONOp_ContainsAny,
+            proto::plan::GenericValue::ValCase::kStringVal);
+        auto start = std::chrono::steady_clock::now();
+        auto final = visitor.call_child(*plan.predicate_.value());
+        std::cout << "cost"
+                  << std::chrono::duration_cast<std::chrono::microseconds>(
+                         std::chrono::steady_clock::now() - start)
+                         .count()
+                  << std::endl;
+        EXPECT_EQ(final.size(), N * num_iters);
+
+        for (int i = 0; i < N * num_iters; ++i) {
+            auto ans = final[i];
+            auto array = milvus::Json(simdjson::padded_string(json_col[i]))
+                             .array_at(pointer);
+            std::vector<std::string_view> res;
+            for (const auto& element : array) {
+                res.push_back(element.template get<std::string_view>());
+            }
+            ASSERT_EQ(ans, check(res));
+        }
+    }
+}
+
+TEST(Expr, TestJsonContainsAll) {
+    using namespace milvus;
+    using namespace milvus::query;
+    using namespace milvus::segcore;
+
+    auto schema = std::make_shared<Schema>();
+    auto i64_fid = schema->AddDebugField("id", DataType::INT64);
+    auto json_fid = schema->AddDebugField("json", DataType::JSON);
+    schema->set_primary_field_id(i64_fid);
+
+    auto seg = CreateGrowingSegment(schema, empty_index_meta);
+    int N = 10000;
+    std::vector<std::string> json_col;
+    int num_iters = 2;
+    for (int iter = 0; iter < num_iters; ++iter) {
+        auto raw_data = DataGenForJsonArray(schema, N, iter);
+        auto new_json_col = raw_data.get_col<std::string>(json_fid);
+
+        json_col.insert(
+            json_col.end(), new_json_col.begin(), new_json_col.end());
+        seg->PreInsert(N);
+        seg->Insert(iter * N,
+                    N,
+                    raw_data.row_ids_.data(),
+                    raw_data.timestamps_.data(),
+                    raw_data.raw_);
+    }
+
+    auto seg_promote = dynamic_cast<SegmentGrowingImpl*>(seg.get());
+    ExecExprVisitor visitor(
+        *seg_promote, seg_promote->get_row_count(), MAX_TIMESTAMP);
+
+    std::vector<Testcase<bool>> bool_testcases{{{true, true}, {"bool"}},
+                                               {{false, false}, {"bool"}}};
+
+    for (auto testcase : bool_testcases) {
+        auto check = [&](const std::vector<bool>& values) {
+            for(auto const& e : testcase.term) {
+                if (std::find(values.begin(), values.end(), e) == values.end()) {
+                    return false;
+                }
+            }
+            return true;
+        };
+        RetrievePlanNode plan;
+        auto pointer = milvus::Json::pointer(testcase.nested_path);
+        plan.predicate_ = std::make_unique<JsonContainsExprImpl<bool>>(
+            ColumnInfo(json_fid, DataType::JSON, testcase.nested_path),
+            testcase.term,
+            true,
+            proto::plan::JSONContainsExpr_JSONOp_ContainsAll,
+            proto::plan::GenericValue::ValCase::kBoolVal);
+        auto start = std::chrono::steady_clock::now();
+        auto final = visitor.call_child(*plan.predicate_.value());
+        std::cout << "cost"
+                  << std::chrono::duration_cast<std::chrono::microseconds>(
+                         std::chrono::steady_clock::now() - start)
+                         .count()
+                  << std::endl;
+        EXPECT_EQ(final.size(), N * num_iters);
+
+        for (int i = 0; i < N * num_iters; ++i) {
+            auto ans = final[i];
+            auto array = milvus::Json(simdjson::padded_string(json_col[i]))
+                             .array_at(pointer);
+            std::vector<bool> res;
+            for (const auto& element : array) {
+                res.push_back(element.template get<bool>());
+            }
+            ASSERT_EQ(ans, check(res));
+        }
+    }
+
+    std::vector<Testcase<double>> double_testcases{
+        {{1.123, 10.34}, {"double"}},
+        {{10.34, 100.234}, {"double"}},
+        {{100.234, 1000.4546}, {"double"}},
+        {{1000.4546, 1.123}, {"double"}},
+        {{1000.4546, 10.34}, {"double"}},
+        {{1.123, 100.234}, {"double"}},
+    };
+
+    for (auto testcase : double_testcases) {
+        auto check = [&](const std::vector<double>& values) {
+            for(auto const& e : testcase.term) {
+                if (std::find(values.begin(), values.end(), e) == values.end()) {
+                    return false;
+                }
+            }
+            return true;
+        };
+        RetrievePlanNode plan;
+        auto pointer = milvus::Json::pointer(testcase.nested_path);
+        plan.predicate_ = std::make_unique<JsonContainsExprImpl<double>>(
+            ColumnInfo(json_fid, DataType::JSON, testcase.nested_path),
+            testcase.term,
+            true,
+            proto::plan::JSONContainsExpr_JSONOp_ContainsAll,
+            proto::plan::GenericValue::ValCase::kFloatVal);
+        auto start = std::chrono::steady_clock::now();
+        auto final = visitor.call_child(*plan.predicate_.value());
+        std::cout << "cost"
+                  << std::chrono::duration_cast<std::chrono::microseconds>(
+                         std::chrono::steady_clock::now() - start)
+                         .count()
+                  << std::endl;
+        EXPECT_EQ(final.size(), N * num_iters);
+
+        for (int i = 0; i < N * num_iters; ++i) {
+            auto ans = final[i];
+            auto array = milvus::Json(simdjson::padded_string(json_col[i]))
+                             .array_at(pointer);
+            std::vector<double> res;
+            for (const auto& element : array) {
+                res.push_back(element.template get<double>());
+            }
+            ASSERT_EQ(ans, check(res));
+        }
+    }
+
+    std::vector<Testcase<int64_t>> testcases{
+        {{1, 10}, {"int"}},
+        {{10, 100}, {"int"}},
+        {{100, 1000}, {"int"}},
+        {{1000, 10}, {"int"}},
+        {{2, 4, 6, 8, 10}, {"int"}},
+        {{1, 2, 3, 4, 5}, {"int"}},
+    };
+
+    for (auto testcase : testcases) {
+        auto check = [&](const std::vector<int64_t>& values) {
+            for(auto const& e : testcase.term) {
+                if (std::find(values.begin(), values.end(), e) == values.end()) {
+                    return false;
+                }
+            }
+            return true;
+        };
+        RetrievePlanNode plan;
+        auto pointer = milvus::Json::pointer(testcase.nested_path);
+        plan.predicate_ = std::make_unique<JsonContainsExprImpl<int64_t>>(
+            ColumnInfo(json_fid, DataType::JSON, testcase.nested_path),
+            testcase.term,
+            true,
+            proto::plan::JSONContainsExpr_JSONOp_ContainsAll,
+            proto::plan::GenericValue::ValCase::kInt64Val);
+        auto start = std::chrono::steady_clock::now();
+        auto final = visitor.call_child(*plan.predicate_.value());
+        std::cout << "cost"
+                  << std::chrono::duration_cast<std::chrono::microseconds>(
+                         std::chrono::steady_clock::now() - start)
+                         .count()
+                  << std::endl;
+        EXPECT_EQ(final.size(), N * num_iters);
+
+        for (int i = 0; i < N * num_iters; ++i) {
+            auto ans = final[i];
+            auto array = milvus::Json(simdjson::padded_string(json_col[i]))
+                             .array_at(pointer);
+            std::vector<int64_t> res;
+            for (const auto& element : array) {
+                res.push_back(element.template get<int64_t>());
+            }
+            ASSERT_EQ(ans, check(res));
+        }
+    }
+
+    std::vector<Testcase<std::string>> testcases_string = {
+        {{"1sads", "10dsf"}, {"string"}},
+        {{"10dsf", "100"}, {"string"}},
+        {{"100", "10dsf", "1sads"}, {"string"}},
+        {{"100ddfdsssdfdsfsd0", "100"}, {"string"}},
+    };
+
+    for (auto testcase : testcases_string) {
+        auto check = [&](const std::vector<std::string_view>& values) {
+            for(auto const& e : testcase.term) {
+                if (std::find(values.begin(), values.end(), e) == values.end()) {
+                    return false;
+                }
+            }
+            return true;
+        };
+        RetrievePlanNode plan;
+        auto pointer = milvus::Json::pointer(testcase.nested_path);
+        plan.predicate_ = std::make_unique<JsonContainsExprImpl<std::string>>(
+            ColumnInfo(json_fid, DataType::JSON, testcase.nested_path),
+            testcase.term,
+            true,
+            proto::plan::JSONContainsExpr_JSONOp_ContainsAll,
+            proto::plan::GenericValue::ValCase::kStringVal);
+        auto start = std::chrono::steady_clock::now();
+        auto final = visitor.call_child(*plan.predicate_.value());
+        std::cout << "cost"
+                  << std::chrono::duration_cast<std::chrono::microseconds>(
+                         std::chrono::steady_clock::now() - start)
+                         .count()
+                  << std::endl;
+        EXPECT_EQ(final.size(), N * num_iters);
+
+        for (int i = 0; i < N * num_iters; ++i) {
+            auto ans = final[i];
+            auto array = milvus::Json(simdjson::padded_string(json_col[i]))
+                             .array_at(pointer);
+            std::vector<std::string_view> res;
+            for (const auto& element : array) {
+                res.push_back(element.template get<std::string_view>());
+            }
+            ASSERT_EQ(ans, check(res));
+        }
+    }
+}
+
+
+TEST(Expr, TestJsonContainsArray) {
+    using namespace milvus;
+    using namespace milvus::query;
+    using namespace milvus::segcore;
+
+    auto schema = std::make_shared<Schema>();
+    auto i64_fid = schema->AddDebugField("id", DataType::INT64);
+    auto json_fid = schema->AddDebugField("json", DataType::JSON);
+    schema->set_primary_field_id(i64_fid);
+
+    auto seg = CreateGrowingSegment(schema, empty_index_meta);
+    int N = 10000;
+    std::vector<std::string> json_col;
+    int num_iters = 2;
+    for (int iter = 0; iter < num_iters; ++iter) {
+        auto raw_data = DataGenForJsonArray(schema, N, iter);
+        auto new_json_col = raw_data.get_col<std::string>(json_fid);
+
+        json_col.insert(
+            json_col.end(), new_json_col.begin(), new_json_col.end());
+        seg->PreInsert(N);
+        seg->Insert(iter * N,
+                    N,
+                    raw_data.row_ids_.data(),
+                    raw_data.timestamps_.data(),
+                    raw_data.raw_);
+    }
+
+    auto seg_promote = dynamic_cast<SegmentGrowingImpl*>(seg.get());
+    ExecExprVisitor visitor(
+        *seg_promote, seg_promote->get_row_count(), MAX_TIMESTAMP);
+
+    proto::plan::Array a;
+    a.set_same_type(false);
+    for (int i = 0; i < 4; ++i) {
+        if (i % 4 == 0) {
+            proto::plan::GenericValue int_val;
+            int_val.set_int64_val(int64_t(i));
+            a.add_array()->CopyFrom(int_val);
+        }else if ((i-1) % 4 == 0 ) {
+            proto::plan::GenericValue bool_val;
+            bool_val.set_bool_val(bool(i));
+            a.add_array()->CopyFrom(bool_val);
+        }else if ((i-2) % 4 == 0 ) {
+            proto::plan::GenericValue float_val;
+            float_val.set_float_val(double(i));
+            a.add_array()->CopyFrom(float_val);
+        }else if ((i-3) % 4 == 0 ) {
+            proto::plan::GenericValue string_val;
+            string_val.set_string_val(std::to_string(i));
+            a.add_array()->CopyFrom(string_val);
+        }
+    }
+    proto::plan::Array b;
+    b.set_same_type(true);
+    proto::plan::GenericValue int_val1;
+    int_val1.set_int64_val(int64_t(1));
+    b.add_array()->CopyFrom(int_val1);
+
+    proto::plan::GenericValue int_val2;
+    int_val2.set_int64_val(int64_t(2));
+    b.add_array()->CopyFrom(int_val2);
+
+    proto::plan::GenericValue int_val3;
+    int_val3.set_int64_val(int64_t(3));
+    b.add_array()->CopyFrom(int_val3);
+
+
+    std::vector<Testcase<proto::plan::Array>> diff_testcases{{{a}, {"string"}},
+                                                             {{b}, {"array"}}};
+
+    for (auto &testcase : diff_testcases) {
+        auto check = [&](const std::vector<bool>& values, int i) {
+            if (testcase.nested_path[0] == "array" && (i == 1 || i == N+1)) {
+                return true;
+            }
+            return false;
+        };
+        RetrievePlanNode plan;
+        auto pointer = milvus::Json::pointer(testcase.nested_path);
+        plan.predicate_ = std::make_unique<JsonContainsExprImpl<proto::plan::Array>>(
+            ColumnInfo(json_fid, DataType::JSON, testcase.nested_path),
+            testcase.term,
+            true,
+            proto::plan::JSONContainsExpr_JSONOp_ContainsAny,
+            proto::plan::GenericValue::ValCase::kArrayVal);
+        auto start = std::chrono::steady_clock::now();
+        auto final = visitor.call_child(*plan.predicate_.value());
+        std::cout << "cost"
+                  << std::chrono::duration_cast<std::chrono::microseconds>(
+                         std::chrono::steady_clock::now() - start)
+                         .count()
+                  << std::endl;
+        EXPECT_EQ(final.size(), N * num_iters);
+
+        for (int i = 0; i < N * num_iters; ++i) {
+            auto ans = final[i];
+            std::vector<bool> res;
+            ASSERT_EQ(ans, check(res, i));
+        }
+    }
+
+    for (auto &testcase : diff_testcases) {
+        auto check = [&](const std::vector<bool>& values, int i) {
+            if (testcase.nested_path[0] == "array" && (i == 1 || i == N+1)) {
+                return true;
+            }
+            return false;
+        };
+        RetrievePlanNode plan;
+        auto pointer = milvus::Json::pointer(testcase.nested_path);
+        plan.predicate_ = std::make_unique<JsonContainsExprImpl<proto::plan::Array>>(
+            ColumnInfo(json_fid, DataType::JSON, testcase.nested_path),
+            testcase.term,
+            true,
+            proto::plan::JSONContainsExpr_JSONOp_ContainsAll,
+            proto::plan::GenericValue::ValCase::kArrayVal);
+        auto start = std::chrono::steady_clock::now();
+        auto final = visitor.call_child(*plan.predicate_.value());
+        std::cout << "cost"
+                  << std::chrono::duration_cast<std::chrono::microseconds>(
+                         std::chrono::steady_clock::now() - start)
+                         .count()
+                  << std::endl;
+        EXPECT_EQ(final.size(), N * num_iters);
+        
+        for (int i = 0; i < N * num_iters; ++i) {
+            auto ans = final[i];
+            std::vector<bool> res;
+            ASSERT_EQ(ans, check(res, i));
+        }
+    }
+}
+
+TEST(Expr, TestJsonContainsDiffType) {
+    using namespace milvus;
+    using namespace milvus::query;
+    using namespace milvus::segcore;
+
+    auto schema = std::make_shared<Schema>();
+    auto i64_fid = schema->AddDebugField("id", DataType::INT64);
+    auto json_fid = schema->AddDebugField("json", DataType::JSON);
+    schema->set_primary_field_id(i64_fid);
+
+    auto seg = CreateGrowingSegment(schema, empty_index_meta);
+    int N = 10000;
+    std::vector<std::string> json_col;
+    int num_iters = 2;
+    for (int iter = 0; iter < num_iters; ++iter) {
+        auto raw_data = DataGenForJsonArray(schema, N, iter);
+        auto new_json_col = raw_data.get_col<std::string>(json_fid);
+
+        json_col.insert(
+            json_col.end(), new_json_col.begin(), new_json_col.end());
+        seg->PreInsert(N);
+        seg->Insert(iter * N,
+                    N,
+                    raw_data.row_ids_.data(),
+                    raw_data.timestamps_.data(),
+                    raw_data.raw_);
+    }
+
+    auto seg_promote = dynamic_cast<SegmentGrowingImpl*>(seg.get());
+    ExecExprVisitor visitor(
+        *seg_promote, seg_promote->get_row_count(), MAX_TIMESTAMP);
+
+    proto::plan::GenericValue v;
+    auto a = v.mutable_array_val();
+    proto::plan::GenericValue int_val;
+    int_val.set_int64_val(int64_t(1));
+    a->add_array()->CopyFrom(int_val);
+    proto::plan::GenericValue bool_val;
+    bool_val.set_bool_val(bool(false));
+    a->add_array()->CopyFrom(bool_val);
+    proto::plan::GenericValue float_val;
+    float_val.set_float_val(double(100.34));
+    a->add_array()->CopyFrom(float_val);
+    proto::plan::GenericValue string_val;
+    string_val.set_string_val("10dsf");
+    a->add_array()->CopyFrom(string_val);
+//    a->set_same_type(false);
+//    v.set_allocated_array_val(a);
+
+    std::vector<Testcase<proto::plan::GenericValue>> diff_testcases{{{v}, {"string"}}};
+
+    for (auto &testcase : diff_testcases) {
+        auto check = [&](const std::vector<std::string_view>& values) {
+            return std::find(values.begin(), values.end(), std::string_view("10dsf")) !=
+                   values.end();
+        };
+        RetrievePlanNode plan;
+        auto pointer = milvus::Json::pointer(testcase.nested_path);
+        plan.predicate_ = std::make_unique<JsonContainsExprImpl<proto::plan::GenericValue>>(
+            ColumnInfo(json_fid, DataType::JSON, testcase.nested_path),
+            testcase.term,
+            false,
+            proto::plan::JSONContainsExpr_JSONOp_ContainsAny,
+            proto::plan::GenericValue::ValCase::VAL_NOT_SET);
+        auto start = std::chrono::steady_clock::now();
+        auto final = visitor.call_child(*plan.predicate_.value());
+        std::cout << "cost"
+                  << std::chrono::duration_cast<std::chrono::microseconds>(
+                         std::chrono::steady_clock::now() - start)
+                         .count()
+                  << std::endl;
+        EXPECT_EQ(final.size(), N * num_iters);
+
+        for (int i = 0; i < N * num_iters; ++i) {
+            auto ans = final[i];
+            auto array = milvus::Json(simdjson::padded_string(json_col[i]))
+                             .array_at(pointer);
+            std::vector<std::string_view> res;
+            for (const auto& element : array) {
+                res.push_back(element.template get<std::string_view>());
+            }
+
+            ASSERT_EQ(ans, check(res));
+        }
+    }
+
+    for (auto &testcase : diff_testcases) {
+        auto check = [&](const std::vector<std::string_view>& values) {
+            return false;
+        };
+        RetrievePlanNode plan;
+        auto pointer = milvus::Json::pointer(testcase.nested_path);
+        plan.predicate_ = std::make_unique<JsonContainsExprImpl<proto::plan::GenericValue>>(
+            ColumnInfo(json_fid, DataType::JSON, testcase.nested_path),
+            testcase.term,
+            false,
+            proto::plan::JSONContainsExpr_JSONOp_ContainsAll,
+            proto::plan::GenericValue::ValCase::VAL_NOT_SET);
+        auto start = std::chrono::steady_clock::now();
+        auto final = visitor.call_child(*plan.predicate_.value());
+        std::cout << "cost"
+                  << std::chrono::duration_cast<std::chrono::microseconds>(
+                         std::chrono::steady_clock::now() - start)
+                         .count()
+                  << std::endl;
+        EXPECT_EQ(final.size(), N * num_iters);
+
+        for (int i = 0; i < N * num_iters; ++i) {
+            auto ans = final[i];
+            auto array = milvus::Json(simdjson::padded_string(json_col[i]))
+                             .array_at(pointer);
+            std::vector<std::string_view> res;
+            for (const auto& element : array) {
+                res.push_back(element.template get<std::string_view>());
+            }
+
+            ASSERT_EQ(ans, check(res));
+        }
+    }
+}
+

internal/core/unittest/test_utils/DataGen.h

@@ -407,17 +407,20 @@ DataGenForJsonArray(SchemaPtr schema,
                     std::vector<std::string> doubleVec;
                     std::vector<std::string> stringVec;
                     std::vector<std::string> boolVec;
-                    for (int i = 0; i < array_len; ++i) {
+                    std::vector<std::string> arrayVec;
+                    for (int j = 0; j < array_len; ++j) {
                         intVec.push_back(std::to_string(er()));
                         doubleVec.push_back(
                             std::to_string(static_cast<double>(er())));
                         stringVec.push_back("\"" + std::to_string(er()) + "\"");
                         boolVec.push_back(i % 2 == 0 ? "true" : "false");
+                        arrayVec.push_back(fmt::format("[{}, {}, {}]", i, i+1, i+2));
                     }
                     auto str = R"({"int":[)" + join(intVec, ",") +
                                R"(],"double":[)" + join(doubleVec, ",") +
                                R"(],"string":[)" + join(stringVec, ",") +
-                               R"(],"bool": [)" + join(boolVec, ",") + "]}";
+                               R"(],"bool": [)" + join(boolVec, ",") +
+                               R"(],"array": [)" + join(arrayVec, ",") + "]}";
                     //std::cout << str << std::endl;
                     data[i] = str;
                 }

internal/parser/planparserv2/Plan.g4

@@ -12,6 +12,7 @@ expr:
 	| Identifier											                     # Identifier
 	| JSONIdentifier                                                             # JSONIdentifier
 	| '(' expr ')'											                     # Parens
+	| '[' expr (',' expr)* ','? ']'                                              # Array
 	| expr LIKE StringLiteral                                                    # Like
 	| expr POW expr											                     # Power
 	| op = (ADD | SUB | BNOT | NOT) expr					                     # Unary
@@ -22,6 +23,8 @@ expr:
 	| expr op = (IN | NIN) ('[' expr (',' expr)* ','? ']')                       # Term
 	| expr op = (IN | NIN) EmptyTerm                                             # EmptyTerm
 	| JSONContains'('expr',' expr')'                                             # JSONContains
+	| JSONContainsAll'('expr',' expr')'                                          # JSONContainsAll
+	| JSONContainsAny'('expr',' expr')'                                          # JSONContainsAny
 	| expr op1 = (LT | LE) (Identifier | JSONIdentifier) op2 = (LT | LE) expr	 # Range
 	| expr op1 = (GT | GE) (Identifier | JSONIdentifier) op2 = (GT | GE) expr    # ReverseRange
 	| expr op = (LT | LE | GT | GE) expr					                     # Relational
@@ -76,6 +79,8 @@ NIN: 'not in';
 EmptyTerm: '[' (Whitespace | Newline)* ']';
 
 JSONContains: 'json_contains' | 'JSON_CONTAINS';
+JSONContainsAll: 'json_contains_all' | 'JSON_CONTAINS_ALL';
+JSONContainsAny: 'json_contains_any' | 'JSON_CONTAINS_ANY';
 
 BooleanConstant: 'true' | 'True' | 'TRUE' | 'false' | 'False' | 'FALSE';
 

internal/parser/planparserv2/generated/Plan.interp

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

internal/parser/planparserv2/generated/Plan.tokens

@@ -30,14 +30,16 @@ IN=29
 NIN=30
 EmptyTerm=31
 JSONContains=32
-BooleanConstant=33
-IntegerConstant=34
-FloatingConstant=35
-Identifier=36
-StringLiteral=37
-JSONIdentifier=38
-Whitespace=39
-Newline=40
+JSONContainsAll=33
+JSONContainsAny=34
+BooleanConstant=35
+IntegerConstant=36
+FloatingConstant=37
+Identifier=38
+StringLiteral=39
+JSONIdentifier=40
+Whitespace=41
+Newline=42
 '('=1
 ')'=2
 '['=3

internal/parser/planparserv2/generated/PlanLexer.tokens

@@ -30,14 +30,16 @@ IN=29
 NIN=30
 EmptyTerm=31
 JSONContains=32
-BooleanConstant=33
-IntegerConstant=34
-FloatingConstant=35
-Identifier=36
-StringLiteral=37
-JSONIdentifier=38
-Whitespace=39
-Newline=40
+JSONContainsAll=33
+JSONContainsAny=34
+BooleanConstant=35
+IntegerConstant=36
+FloatingConstant=37
+Identifier=38
+StringLiteral=39
+JSONIdentifier=40
+Whitespace=41
+Newline=42
 '('=1
 ')'=2
 '['=3

internal/parser/planparserv2/generated/plan_base_visitor.go

@@ -23,6 +23,10 @@ func (v *BasePlanVisitor) VisitFloating(ctx *FloatingContext) interface{} {
 	return v.VisitChildren(ctx)
 }
 
+func (v *BasePlanVisitor) VisitJSONContainsAll(ctx *JSONContainsAllContext) interface{} {
+	return v.VisitChildren(ctx)
+}
+
 func (v *BasePlanVisitor) VisitLogicalOr(ctx *LogicalOrContext) interface{} {
 	return v.VisitChildren(ctx)
 }
@@ -91,6 +95,14 @@ func (v *BasePlanVisitor) VisitInteger(ctx *IntegerContext) interface{} {
 	return v.VisitChildren(ctx)
 }
 
+func (v *BasePlanVisitor) VisitArray(ctx *ArrayContext) interface{} {
+	return v.VisitChildren(ctx)
+}
+
+func (v *BasePlanVisitor) VisitJSONContainsAny(ctx *JSONContainsAnyContext) interface{} {
+	return v.VisitChildren(ctx)
+}
+
 func (v *BasePlanVisitor) VisitBitXor(ctx *BitXorContext) interface{} {
 	return v.VisitChildren(ctx)
 }

internal/parser/planparserv2/generated/plan_lexer.go

@@ -14,7 +14,7 @@ var _ = fmt.Printf
 var _ = unicode.IsLetter
 
 var serializedLexerAtn = []uint16{
-	3, 24715, 42794, 33075, 47597, 16764, 15335, 30598, 22884, 2, 42, 530,
+	3, 24715, 42794, 33075, 47597, 16764, 15335, 30598, 22884, 2, 44, 606,
 	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,
@@ -26,241 +26,274 @@ var serializedLexerAtn = []uint16{
 	9, 44, 4, 45, 9, 45, 4, 46, 9, 46, 4, 47, 9, 47, 4, 48, 9, 48, 4, 49, 9,
 	49, 4, 50, 9, 50, 4, 51, 9, 51, 4, 52, 9, 52, 4, 53, 9, 53, 4, 54, 9, 54,
 	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, 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, 160, 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, 174, 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, 206, 10, 26, 3, 27, 3, 27, 3, 27, 3, 27, 5, 27, 212,
-	10, 27, 3, 28, 3, 28, 3, 29, 3, 29, 3, 29, 3, 29, 5, 29, 220, 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, 235, 10, 32, 12, 32, 14, 32, 238, 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,
+	60, 9, 60, 4, 61, 9, 61, 4, 62, 9, 62, 4, 63, 9, 63, 4, 64, 9, 64, 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, 164, 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, 178, 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, 210, 10, 26, 3, 27, 3, 27,
+	3, 27, 3, 27, 5, 27, 216, 10, 27, 3, 28, 3, 28, 3, 29, 3, 29, 3, 29, 3,
+	29, 5, 29, 224, 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, 239, 10, 32, 12, 32, 14,
+	32, 242, 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, 5, 33, 268, 10, 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,
+	33, 3, 33, 3, 33, 3, 33, 3, 33, 3, 33, 3, 33, 3, 33, 3, 33, 3, 33, 5, 33,
+	272, 10, 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, 5, 34, 297, 10, 34, 3, 35, 3, 35, 3, 35, 3,
-	35, 5, 35, 303, 10, 35, 3, 36, 3, 36, 5, 36, 307, 10, 36, 3, 37, 3, 37,
-	3, 37, 7, 37, 312, 10, 37, 12, 37, 14, 37, 315, 11, 37, 3, 37, 3, 37, 3,
-	37, 3, 37, 3, 37, 5, 37, 322, 10, 37, 3, 38, 5, 38, 325, 10, 38, 3, 38,
-	3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 5, 38, 334, 10, 38, 3, 38, 3,
-	38, 7, 38, 338, 10, 38, 12, 38, 14, 38, 341, 11, 38, 3, 38, 3, 38, 3, 38,
-	3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 5, 38, 352, 10, 38, 3, 38, 3,
-	38, 3, 38, 3, 38, 7, 38, 358, 10, 38, 12, 38, 14, 38, 361, 11, 38, 3, 38,
-	3, 38, 5, 38, 365, 10, 38, 3, 39, 3, 39, 3, 39, 3, 39, 5, 39, 371, 10,
-	39, 3, 39, 3, 39, 6, 39, 375, 10, 39, 13, 39, 14, 39, 376, 3, 40, 3, 40,
-	3, 40, 5, 40, 382, 10, 40, 3, 41, 3, 41, 3, 42, 3, 42, 3, 43, 3, 43, 3,
-	43, 6, 43, 391, 10, 43, 13, 43, 14, 43, 392, 3, 44, 3, 44, 7, 44, 397,
-	10, 44, 12, 44, 14, 44, 400, 11, 44, 3, 44, 5, 44, 403, 10, 44, 3, 45,
-	3, 45, 7, 45, 407, 10, 45, 12, 45, 14, 45, 410, 11, 45, 3, 46, 3, 46, 3,
-	46, 3, 46, 3, 47, 3, 47, 3, 48, 3, 48, 3, 49, 3, 49, 3, 50, 3, 50, 3, 50,
-	3, 50, 3, 50, 3, 51, 3, 51, 3, 51, 3, 51, 3, 51, 3, 51, 3, 51, 3, 51, 3,
-	51, 3, 51, 5, 51, 437, 10, 51, 3, 52, 3, 52, 5, 52, 441, 10, 52, 3, 52,
-	3, 52, 3, 52, 5, 52, 446, 10, 52, 3, 53, 3, 53, 3, 53, 3, 53, 5, 53, 452,
-	10, 53, 3, 53, 3, 53, 3, 54, 5, 54, 457, 10, 54, 3, 54, 3, 54, 3, 54, 3,
-	54, 3, 54, 5, 54, 464, 10, 54, 3, 55, 3, 55, 5, 55, 468, 10, 55, 3, 55,
-	3, 55, 3, 56, 6, 56, 473, 10, 56, 13, 56, 14, 56, 474, 3, 57, 5, 57, 478,
-	10, 57, 3, 57, 3, 57, 3, 57, 3, 57, 3, 57, 5, 57, 485, 10, 57, 3, 58, 6,
-	58, 488, 10, 58, 13, 58, 14, 58, 489, 3, 59, 3, 59, 5, 59, 494, 10, 59,
-	3, 59, 3, 59, 3, 60, 3, 60, 3, 60, 3, 60, 3, 60, 5, 60, 503, 10, 60, 3,
-	60, 5, 60, 506, 10, 60, 3, 60, 3, 60, 3, 60, 3, 60, 3, 60, 5, 60, 513,
-	10, 60, 3, 61, 6, 61, 516, 10, 61, 13, 61, 14, 61, 517, 3, 61, 3, 61, 3,
-	62, 3, 62, 5, 62, 524, 10, 62, 3, 62, 5, 62, 527, 10, 62, 3, 62, 3, 62,
-	2, 2, 63, 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, 2, 81, 2, 83, 2, 85, 2, 87, 2, 89, 2, 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, 41, 123, 42, 3, 2, 19, 3, 2, 41, 41, 4,
-	2, 36, 36, 94, 94, 5, 2, 36, 36, 41, 41, 94, 94, 5, 2, 78, 78, 87, 87,
-	119, 119, 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, 564, 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, 121, 3, 2, 2, 2, 2, 123, 3, 2, 2, 2, 3, 125, 3, 2, 2, 2, 5, 127,
-	3, 2, 2, 2, 7, 129, 3, 2, 2, 2, 9, 131, 3, 2, 2, 2, 11, 133, 3, 2, 2, 2,
-	13, 135, 3, 2, 2, 2, 15, 137, 3, 2, 2, 2, 17, 140, 3, 2, 2, 2, 19, 142,
-	3, 2, 2, 2, 21, 145, 3, 2, 2, 2, 23, 148, 3, 2, 2, 2, 25, 159, 3, 2, 2,
-	2, 27, 173, 3, 2, 2, 2, 29, 175, 3, 2, 2, 2, 31, 177, 3, 2, 2, 2, 33, 179,
-	3, 2, 2, 2, 35, 181, 3, 2, 2, 2, 37, 183, 3, 2, 2, 2, 39, 185, 3, 2, 2,
-	2, 41, 188, 3, 2, 2, 2, 43, 191, 3, 2, 2, 2, 45, 194, 3, 2, 2, 2, 47, 196,
-	3, 2, 2, 2, 49, 198, 3, 2, 2, 2, 51, 205, 3, 2, 2, 2, 53, 211, 3, 2, 2,
-	2, 55, 213, 3, 2, 2, 2, 57, 219, 3, 2, 2, 2, 59, 221, 3, 2, 2, 2, 61, 224,
-	3, 2, 2, 2, 63, 231, 3, 2, 2, 2, 65, 267, 3, 2, 2, 2, 67, 296, 3, 2, 2,
-	2, 69, 302, 3, 2, 2, 2, 71, 306, 3, 2, 2, 2, 73, 321, 3, 2, 2, 2, 75, 364,
-	3, 2, 2, 2, 77, 366, 3, 2, 2, 2, 79, 381, 3, 2, 2, 2, 81, 383, 3, 2, 2,
-	2, 83, 385, 3, 2, 2, 2, 85, 387, 3, 2, 2, 2, 87, 402, 3, 2, 2, 2, 89, 404,
-	3, 2, 2, 2, 91, 411, 3, 2, 2, 2, 93, 415, 3, 2, 2, 2, 95, 417, 3, 2, 2,
-	2, 97, 419, 3, 2, 2, 2, 99, 421, 3, 2, 2, 2, 101, 436, 3, 2, 2, 2, 103,
-	445, 3, 2, 2, 2, 105, 447, 3, 2, 2, 2, 107, 463, 3, 2, 2, 2, 109, 465,
-	3, 2, 2, 2, 111, 472, 3, 2, 2, 2, 113, 484, 3, 2, 2, 2, 115, 487, 3, 2,
-	2, 2, 117, 491, 3, 2, 2, 2, 119, 512, 3, 2, 2, 2, 121, 515, 3, 2, 2, 2,
-	123, 526, 3, 2, 2, 2, 125, 126, 7, 42, 2, 2, 126, 4, 3, 2, 2, 2, 127, 128,
-	7, 43, 2, 2, 128, 6, 3, 2, 2, 2, 129, 130, 7, 93, 2, 2, 130, 8, 3, 2, 2,
-	2, 131, 132, 7, 46, 2, 2, 132, 10, 3, 2, 2, 2, 133, 134, 7, 95, 2, 2, 134,
-	12, 3, 2, 2, 2, 135, 136, 7, 62, 2, 2, 136, 14, 3, 2, 2, 2, 137, 138, 7,
-	62, 2, 2, 138, 139, 7, 63, 2, 2, 139, 16, 3, 2, 2, 2, 140, 141, 7, 64,
-	2, 2, 141, 18, 3, 2, 2, 2, 142, 143, 7, 64, 2, 2, 143, 144, 7, 63, 2, 2,
-	144, 20, 3, 2, 2, 2, 145, 146, 7, 63, 2, 2, 146, 147, 7, 63, 2, 2, 147,
-	22, 3, 2, 2, 2, 148, 149, 7, 35, 2, 2, 149, 150, 7, 63, 2, 2, 150, 24,
-	3, 2, 2, 2, 151, 152, 7, 110, 2, 2, 152, 153, 7, 107, 2, 2, 153, 154, 7,
-	109, 2, 2, 154, 160, 7, 103, 2, 2, 155, 156, 7, 78, 2, 2, 156, 157, 7,
-	75, 2, 2, 157, 158, 7, 77, 2, 2, 158, 160, 7, 71, 2, 2, 159, 151, 3, 2,
-	2, 2, 159, 155, 3, 2, 2, 2, 160, 26, 3, 2, 2, 2, 161, 162, 7, 103, 2, 2,
-	162, 163, 7, 122, 2, 2, 163, 164, 7, 107, 2, 2, 164, 165, 7, 117, 2, 2,
-	165, 166, 7, 118, 2, 2, 166, 174, 7, 117, 2, 2, 167, 168, 7, 71, 2, 2,
-	168, 169, 7, 90, 2, 2, 169, 170, 7, 75, 2, 2, 170, 171, 7, 85, 2, 2, 171,
-	172, 7, 86, 2, 2, 172, 174, 7, 85, 2, 2, 173, 161, 3, 2, 2, 2, 173, 167,
-	3, 2, 2, 2, 174, 28, 3, 2, 2, 2, 175, 176, 7, 45, 2, 2, 176, 30, 3, 2,
-	2, 2, 177, 178, 7, 47, 2, 2, 178, 32, 3, 2, 2, 2, 179, 180, 7, 44, 2, 2,
-	180, 34, 3, 2, 2, 2, 181, 182, 7, 49, 2, 2, 182, 36, 3, 2, 2, 2, 183, 184,
-	7, 39, 2, 2, 184, 38, 3, 2, 2, 2, 185, 186, 7, 44, 2, 2, 186, 187, 7, 44,
-	2, 2, 187, 40, 3, 2, 2, 2, 188, 189, 7, 62, 2, 2, 189, 190, 7, 62, 2, 2,
-	190, 42, 3, 2, 2, 2, 191, 192, 7, 64, 2, 2, 192, 193, 7, 64, 2, 2, 193,
-	44, 3, 2, 2, 2, 194, 195, 7, 40, 2, 2, 195, 46, 3, 2, 2, 2, 196, 197, 7,
-	126, 2, 2, 197, 48, 3, 2, 2, 2, 198, 199, 7, 96, 2, 2, 199, 50, 3, 2, 2,
-	2, 200, 201, 7, 40, 2, 2, 201, 206, 7, 40, 2, 2, 202, 203, 7, 99, 2, 2,
-	203, 204, 7, 112, 2, 2, 204, 206, 7, 102, 2, 2, 205, 200, 3, 2, 2, 2, 205,
-	202, 3, 2, 2, 2, 206, 52, 3, 2, 2, 2, 207, 208, 7, 126, 2, 2, 208, 212,
-	7, 126, 2, 2, 209, 210, 7, 113, 2, 2, 210, 212, 7, 116, 2, 2, 211, 207,
-	3, 2, 2, 2, 211, 209, 3, 2, 2, 2, 212, 54, 3, 2, 2, 2, 213, 214, 7, 128,
-	2, 2, 214, 56, 3, 2, 2, 2, 215, 220, 7, 35, 2, 2, 216, 217, 7, 112, 2,
-	2, 217, 218, 7, 113, 2, 2, 218, 220, 7, 118, 2, 2, 219, 215, 3, 2, 2, 2,
-	219, 216, 3, 2, 2, 2, 220, 58, 3, 2, 2, 2, 221, 222, 7, 107, 2, 2, 222,
-	223, 7, 112, 2, 2, 223, 60, 3, 2, 2, 2, 224, 225, 7, 112, 2, 2, 225, 226,
-	7, 113, 2, 2, 226, 227, 7, 118, 2, 2, 227, 228, 7, 34, 2, 2, 228, 229,
-	7, 107, 2, 2, 229, 230, 7, 112, 2, 2, 230, 62, 3, 2, 2, 2, 231, 236, 7,
-	93, 2, 2, 232, 235, 5, 121, 61, 2, 233, 235, 5, 123, 62, 2, 234, 232, 3,
-	2, 2, 2, 234, 233, 3, 2, 2, 2, 235, 238, 3, 2, 2, 2, 236, 234, 3, 2, 2,
-	2, 236, 237, 3, 2, 2, 2, 237, 239, 3, 2, 2, 2, 238, 236, 3, 2, 2, 2, 239,
-	240, 7, 95, 2, 2, 240, 64, 3, 2, 2, 2, 241, 242, 7, 108, 2, 2, 242, 243,
-	7, 117, 2, 2, 243, 244, 7, 113, 2, 2, 244, 245, 7, 112, 2, 2, 245, 246,
-	7, 97, 2, 2, 246, 247, 7, 101, 2, 2, 247, 248, 7, 113, 2, 2, 248, 249,
-	7, 112, 2, 2, 249, 250, 7, 118, 2, 2, 250, 251, 7, 99, 2, 2, 251, 252,
-	7, 107, 2, 2, 252, 253, 7, 112, 2, 2, 253, 268, 7, 117, 2, 2, 254, 255,
-	7, 76, 2, 2, 255, 256, 7, 85, 2, 2, 256, 257, 7, 81, 2, 2, 257, 258, 7,
-	80, 2, 2, 258, 259, 7, 97, 2, 2, 259, 260, 7, 69, 2, 2, 260, 261, 7, 81,
-	2, 2, 261, 262, 7, 80, 2, 2, 262, 263, 7, 86, 2, 2, 263, 264, 7, 67, 2,
-	2, 264, 265, 7, 75, 2, 2, 265, 266, 7, 80, 2, 2, 266, 268, 7, 85, 2, 2,
-	267, 241, 3, 2, 2, 2, 267, 254, 3, 2, 2, 2, 268, 66, 3, 2, 2, 2, 269, 270,
-	7, 118, 2, 2, 270, 271, 7, 116, 2, 2, 271, 272, 7, 119, 2, 2, 272, 297,
-	7, 103, 2, 2, 273, 274, 7, 86, 2, 2, 274, 275, 7, 116, 2, 2, 275, 276,
-	7, 119, 2, 2, 276, 297, 7, 103, 2, 2, 277, 278, 7, 86, 2, 2, 278, 279,
-	7, 84, 2, 2, 279, 280, 7, 87, 2, 2, 280, 297, 7, 71, 2, 2, 281, 282, 7,
-	104, 2, 2, 282, 283, 7, 99, 2, 2, 283, 284, 7, 110, 2, 2, 284, 285, 7,
-	117, 2, 2, 285, 297, 7, 103, 2, 2, 286, 287, 7, 72, 2, 2, 287, 288, 7,
-	99, 2, 2, 288, 289, 7, 110, 2, 2, 289, 290, 7, 117, 2, 2, 290, 297, 7,
-	103, 2, 2, 291, 292, 7, 72, 2, 2, 292, 293, 7, 67, 2, 2, 293, 294, 7, 78,
-	2, 2, 294, 295, 7, 85, 2, 2, 295, 297, 7, 71, 2, 2, 296, 269, 3, 2, 2,
-	2, 296, 273, 3, 2, 2, 2, 296, 277, 3, 2, 2, 2, 296, 281, 3, 2, 2, 2, 296,
-	286, 3, 2, 2, 2, 296, 291, 3, 2, 2, 2, 297, 68, 3, 2, 2, 2, 298, 303, 5,
-	87, 44, 2, 299, 303, 5, 89, 45, 2, 300, 303, 5, 91, 46, 2, 301, 303, 5,
-	85, 43, 2, 302, 298, 3, 2, 2, 2, 302, 299, 3, 2, 2, 2, 302, 300, 3, 2,
-	2, 2, 302, 301, 3, 2, 2, 2, 303, 70, 3, 2, 2, 2, 304, 307, 5, 103, 52,
-	2, 305, 307, 5, 105, 53, 2, 306, 304, 3, 2, 2, 2, 306, 305, 3, 2, 2, 2,
-	307, 72, 3, 2, 2, 2, 308, 313, 5, 81, 41, 2, 309, 312, 5, 81, 41, 2, 310,
-	312, 5, 83, 42, 2, 311, 309, 3, 2, 2, 2, 311, 310, 3, 2, 2, 2, 312, 315,
-	3, 2, 2, 2, 313, 311, 3, 2, 2, 2, 313, 314, 3, 2, 2, 2, 314, 322, 3, 2,
-	2, 2, 315, 313, 3, 2, 2, 2, 316, 317, 7, 38, 2, 2, 317, 318, 7, 111, 2,
-	2, 318, 319, 7, 103, 2, 2, 319, 320, 7, 118, 2, 2, 320, 322, 7, 99, 2,
-	2, 321, 308, 3, 2, 2, 2, 321, 316, 3, 2, 2, 2, 322, 74, 3, 2, 2, 2, 323,
-	325, 5, 79, 40, 2, 324, 323, 3, 2, 2, 2, 324, 325, 3, 2, 2, 2, 325, 326,
-	3, 2, 2, 2, 326, 327, 7, 36, 2, 2, 327, 339, 8, 38, 2, 2, 328, 333, 7,
-	94, 2, 2, 329, 330, 7, 41, 2, 2, 330, 334, 8, 38, 3, 2, 331, 332, 10, 2,
-	2, 2, 332, 334, 8, 38, 4, 2, 333, 329, 3, 2, 2, 2, 333, 331, 3, 2, 2, 2,
-	334, 338, 3, 2, 2, 2, 335, 336, 10, 3, 2, 2, 336, 338, 8, 38, 5, 2, 337,
-	328, 3, 2, 2, 2, 337, 335, 3, 2, 2, 2, 338, 341, 3, 2, 2, 2, 339, 337,
-	3, 2, 2, 2, 339, 340, 3, 2, 2, 2, 340, 342, 3, 2, 2, 2, 341, 339, 3, 2,
-	2, 2, 342, 343, 7, 36, 2, 2, 343, 365, 8, 38, 6, 2, 344, 345, 7, 41, 2,
-	2, 345, 359, 8, 38, 7, 2, 346, 351, 7, 94, 2, 2, 347, 348, 7, 41, 2, 2,
-	348, 352, 8, 38, 8, 2, 349, 350, 10, 2, 2, 2, 350, 352, 8, 38, 9, 2, 351,
-	347, 3, 2, 2, 2, 351, 349, 3, 2, 2, 2, 352, 358, 3, 2, 2, 2, 353, 354,
-	7, 36, 2, 2, 354, 358, 8, 38, 10, 2, 355, 356, 10, 4, 2, 2, 356, 358, 8,
-	38, 11, 2, 357, 346, 3, 2, 2, 2, 357, 353, 3, 2, 2, 2, 357, 355, 3, 2,
-	2, 2, 358, 361, 3, 2, 2, 2, 359, 357, 3, 2, 2, 2, 359, 360, 3, 2, 2, 2,
-	360, 362, 3, 2, 2, 2, 361, 359, 3, 2, 2, 2, 362, 363, 7, 41, 2, 2, 363,
-	365, 8, 38, 12, 2, 364, 324, 3, 2, 2, 2, 364, 344, 3, 2, 2, 2, 365, 76,
-	3, 2, 2, 2, 366, 374, 5, 73, 37, 2, 367, 370, 7, 93, 2, 2, 368, 371, 5,
-	75, 38, 2, 369, 371, 5, 87, 44, 2, 370, 368, 3, 2, 2, 2, 370, 369, 3, 2,
-	2, 2, 371, 372, 3, 2, 2, 2, 372, 373, 7, 95, 2, 2, 373, 375, 3, 2, 2, 2,
-	374, 367, 3, 2, 2, 2, 375, 376, 3, 2, 2, 2, 376, 374, 3, 2, 2, 2, 376,
-	377, 3, 2, 2, 2, 377, 78, 3, 2, 2, 2, 378, 379, 7, 119, 2, 2, 379, 382,
-	7, 58, 2, 2, 380, 382, 9, 5, 2, 2, 381, 378, 3, 2, 2, 2, 381, 380, 3, 2,
-	2, 2, 382, 80, 3, 2, 2, 2, 383, 384, 9, 6, 2, 2, 384, 82, 3, 2, 2, 2, 385,
-	386, 9, 7, 2, 2, 386, 84, 3, 2, 2, 2, 387, 388, 7, 50, 2, 2, 388, 390,
-	9, 8, 2, 2, 389, 391, 9, 9, 2, 2, 390, 389, 3, 2, 2, 2, 391, 392, 3, 2,
-	2, 2, 392, 390, 3, 2, 2, 2, 392, 393, 3, 2, 2, 2, 393, 86, 3, 2, 2, 2,
-	394, 398, 5, 93, 47, 2, 395, 397, 5, 83, 42, 2, 396, 395, 3, 2, 2, 2, 397,
-	400, 3, 2, 2, 2, 398, 396, 3, 2, 2, 2, 398, 399, 3, 2, 2, 2, 399, 403,
-	3, 2, 2, 2, 400, 398, 3, 2, 2, 2, 401, 403, 7, 50, 2, 2, 402, 394, 3, 2,
-	2, 2, 402, 401, 3, 2, 2, 2, 403, 88, 3, 2, 2, 2, 404, 408, 7, 50, 2, 2,
-	405, 407, 5, 95, 48, 2, 406, 405, 3, 2, 2, 2, 407, 410, 3, 2, 2, 2, 408,
-	406, 3, 2, 2, 2, 408, 409, 3, 2, 2, 2, 409, 90, 3, 2, 2, 2, 410, 408, 3,
-	2, 2, 2, 411, 412, 7, 50, 2, 2, 412, 413, 9, 10, 2, 2, 413, 414, 5, 115,
-	58, 2, 414, 92, 3, 2, 2, 2, 415, 416, 9, 11, 2, 2, 416, 94, 3, 2, 2, 2,
-	417, 418, 9, 12, 2, 2, 418, 96, 3, 2, 2, 2, 419, 420, 9, 13, 2, 2, 420,
-	98, 3, 2, 2, 2, 421, 422, 5, 97, 49, 2, 422, 423, 5, 97, 49, 2, 423, 424,
-	5, 97, 49, 2, 424, 425, 5, 97, 49, 2, 425, 100, 3, 2, 2, 2, 426, 427, 7,
-	94, 2, 2, 427, 428, 7, 119, 2, 2, 428, 429, 3, 2, 2, 2, 429, 437, 5, 99,
-	50, 2, 430, 431, 7, 94, 2, 2, 431, 432, 7, 87, 2, 2, 432, 433, 3, 2, 2,
-	2, 433, 434, 5, 99, 50, 2, 434, 435, 5, 99, 50, 2, 435, 437, 3, 2, 2, 2,
-	436, 426, 3, 2, 2, 2, 436, 430, 3, 2, 2, 2, 437, 102, 3, 2, 2, 2, 438,
-	440, 5, 107, 54, 2, 439, 441, 5, 109, 55, 2, 440, 439, 3, 2, 2, 2, 440,
-	441, 3, 2, 2, 2, 441, 446, 3, 2, 2, 2, 442, 443, 5, 111, 56, 2, 443, 444,
-	5, 109, 55, 2, 444, 446, 3, 2, 2, 2, 445, 438, 3, 2, 2, 2, 445, 442, 3,
-	2, 2, 2, 446, 104, 3, 2, 2, 2, 447, 448, 7, 50, 2, 2, 448, 451, 9, 10,
-	2, 2, 449, 452, 5, 113, 57, 2, 450, 452, 5, 115, 58, 2, 451, 449, 3, 2,
-	2, 2, 451, 450, 3, 2, 2, 2, 452, 453, 3, 2, 2, 2, 453, 454, 5, 117, 59,
-	2, 454, 106, 3, 2, 2, 2, 455, 457, 5, 111, 56, 2, 456, 455, 3, 2, 2, 2,
-	456, 457, 3, 2, 2, 2, 457, 458, 3, 2, 2, 2, 458, 459, 7, 48, 2, 2, 459,
-	464, 5, 111, 56, 2, 460, 461, 5, 111, 56, 2, 461, 462, 7, 48, 2, 2, 462,
-	464, 3, 2, 2, 2, 463, 456, 3, 2, 2, 2, 463, 460, 3, 2, 2, 2, 464, 108,
-	3, 2, 2, 2, 465, 467, 9, 14, 2, 2, 466, 468, 9, 15, 2, 2, 467, 466, 3,
-	2, 2, 2, 467, 468, 3, 2, 2, 2, 468, 469, 3, 2, 2, 2, 469, 470, 5, 111,
-	56, 2, 470, 110, 3, 2, 2, 2, 471, 473, 5, 83, 42, 2, 472, 471, 3, 2, 2,
-	2, 473, 474, 3, 2, 2, 2, 474, 472, 3, 2, 2, 2, 474, 475, 3, 2, 2, 2, 475,
-	112, 3, 2, 2, 2, 476, 478, 5, 115, 58, 2, 477, 476, 3, 2, 2, 2, 477, 478,
-	3, 2, 2, 2, 478, 479, 3, 2, 2, 2, 479, 480, 7, 48, 2, 2, 480, 485, 5, 115,
-	58, 2, 481, 482, 5, 115, 58, 2, 482, 483, 7, 48, 2, 2, 483, 485, 3, 2,
-	2, 2, 484, 477, 3, 2, 2, 2, 484, 481, 3, 2, 2, 2, 485, 114, 3, 2, 2, 2,
-	486, 488, 5, 97, 49, 2, 487, 486, 3, 2, 2, 2, 488, 489, 3, 2, 2, 2, 489,
-	487, 3, 2, 2, 2, 489, 490, 3, 2, 2, 2, 490, 116, 3, 2, 2, 2, 491, 493,
-	9, 16, 2, 2, 492, 494, 9, 15, 2, 2, 493, 492, 3, 2, 2, 2, 493, 494, 3,
-	2, 2, 2, 494, 495, 3, 2, 2, 2, 495, 496, 5, 111, 56, 2, 496, 118, 3, 2,
-	2, 2, 497, 498, 7, 94, 2, 2, 498, 513, 9, 17, 2, 2, 499, 500, 7, 94, 2,
-	2, 500, 502, 5, 95, 48, 2, 501, 503, 5, 95, 48, 2, 502, 501, 3, 2, 2, 2,
-	502, 503, 3, 2, 2, 2, 503, 505, 3, 2, 2, 2, 504, 506, 5, 95, 48, 2, 505,
-	504, 3, 2, 2, 2, 505, 506, 3, 2, 2, 2, 506, 513, 3, 2, 2, 2, 507, 508,
-	7, 94, 2, 2, 508, 509, 7, 122, 2, 2, 509, 510, 3, 2, 2, 2, 510, 513, 5,
-	115, 58, 2, 511, 513, 5, 101, 51, 2, 512, 497, 3, 2, 2, 2, 512, 499, 3,
-	2, 2, 2, 512, 507, 3, 2, 2, 2, 512, 511, 3, 2, 2, 2, 513, 120, 3, 2, 2,
-	2, 514, 516, 9, 18, 2, 2, 515, 514, 3, 2, 2, 2, 516, 517, 3, 2, 2, 2, 517,
-	515, 3, 2, 2, 2, 517, 518, 3, 2, 2, 2, 518, 519, 3, 2, 2, 2, 519, 520,
-	8, 61, 13, 2, 520, 122, 3, 2, 2, 2, 521, 523, 7, 15, 2, 2, 522, 524, 7,
-	12, 2, 2, 523, 522, 3, 2, 2, 2, 523, 524, 3, 2, 2, 2, 524, 527, 3, 2, 2,
-	2, 525, 527, 7, 12, 2, 2, 526, 521, 3, 2, 2, 2, 526, 525, 3, 2, 2, 2, 527,
-	528, 3, 2, 2, 2, 528, 529, 8, 62, 13, 2, 529, 124, 3, 2, 2, 2, 50, 2, 159,
-	173, 205, 211, 219, 234, 236, 267, 296, 302, 306, 311, 313, 321, 324, 333,
-	337, 339, 351, 357, 359, 364, 370, 376, 381, 392, 398, 402, 408, 436, 440,
-	445, 451, 456, 463, 467, 474, 477, 484, 489, 493, 502, 505, 512, 517, 523,
-	526, 14, 3, 38, 2, 3, 38, 3, 3, 38, 4, 3, 38, 5, 3, 38, 6, 3, 38, 7, 3,
-	38, 8, 3, 38, 9, 3, 38, 10, 3, 38, 11, 3, 38, 12, 8, 2, 2,
+	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, 308, 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,
+	3, 35, 3, 35, 3, 35, 3, 35, 3, 35, 3, 35, 3, 35, 3, 35, 3, 35, 3, 35, 5,
+	35, 344, 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, 3,
+	36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 5, 36, 373,
+	10, 36, 3, 37, 3, 37, 3, 37, 3, 37, 5, 37, 379, 10, 37, 3, 38, 3, 38, 5,
+	38, 383, 10, 38, 3, 39, 3, 39, 3, 39, 7, 39, 388, 10, 39, 12, 39, 14, 39,
+	391, 11, 39, 3, 39, 3, 39, 3, 39, 3, 39, 3, 39, 5, 39, 398, 10, 39, 3,
+	40, 5, 40, 401, 10, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40,
+	5, 40, 410, 10, 40, 3, 40, 3, 40, 7, 40, 414, 10, 40, 12, 40, 14, 40, 417,
+	11, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40,
+	5, 40, 428, 10, 40, 3, 40, 3, 40, 3, 40, 3, 40, 7, 40, 434, 10, 40, 12,
+	40, 14, 40, 437, 11, 40, 3, 40, 3, 40, 5, 40, 441, 10, 40, 3, 41, 3, 41,
+	3, 41, 3, 41, 5, 41, 447, 10, 41, 3, 41, 3, 41, 6, 41, 451, 10, 41, 13,
+	41, 14, 41, 452, 3, 42, 3, 42, 3, 42, 5, 42, 458, 10, 42, 3, 43, 3, 43,
+	3, 44, 3, 44, 3, 45, 3, 45, 3, 45, 6, 45, 467, 10, 45, 13, 45, 14, 45,
+	468, 3, 46, 3, 46, 7, 46, 473, 10, 46, 12, 46, 14, 46, 476, 11, 46, 3,
+	46, 5, 46, 479, 10, 46, 3, 47, 3, 47, 7, 47, 483, 10, 47, 12, 47, 14, 47,
+	486, 11, 47, 3, 48, 3, 48, 3, 48, 3, 48, 3, 49, 3, 49, 3, 50, 3, 50, 3,
+	51, 3, 51, 3, 52, 3, 52, 3, 52, 3, 52, 3, 52, 3, 53, 3, 53, 3, 53, 3, 53,
+	3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 5, 53, 513, 10, 53, 3, 54, 3,
+	54, 5, 54, 517, 10, 54, 3, 54, 3, 54, 3, 54, 5, 54, 522, 10, 54, 3, 55,
+	3, 55, 3, 55, 3, 55, 5, 55, 528, 10, 55, 3, 55, 3, 55, 3, 56, 5, 56, 533,
+	10, 56, 3, 56, 3, 56, 3, 56, 3, 56, 3, 56, 5, 56, 540, 10, 56, 3, 57, 3,
+	57, 5, 57, 544, 10, 57, 3, 57, 3, 57, 3, 58, 6, 58, 549, 10, 58, 13, 58,
+	14, 58, 550, 3, 59, 5, 59, 554, 10, 59, 3, 59, 3, 59, 3, 59, 3, 59, 3,
+	59, 5, 59, 561, 10, 59, 3, 60, 6, 60, 564, 10, 60, 13, 60, 14, 60, 565,
+	3, 61, 3, 61, 5, 61, 570, 10, 61, 3, 61, 3, 61, 3, 62, 3, 62, 3, 62, 3,
+	62, 3, 62, 5, 62, 579, 10, 62, 3, 62, 5, 62, 582, 10, 62, 3, 62, 3, 62,
+	3, 62, 3, 62, 3, 62, 5, 62, 589, 10, 62, 3, 63, 6, 63, 592, 10, 63, 13,
+	63, 14, 63, 593, 3, 63, 3, 63, 3, 64, 3, 64, 5, 64, 600, 10, 64, 3, 64,
+	5, 64, 603, 10, 64, 3, 64, 3, 64, 2, 2, 65, 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, 2,
+	85, 2, 87, 2, 89, 2, 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, 43, 127, 44, 3, 2, 19, 3, 2, 41, 41, 4, 2, 36, 36, 94, 94,
+	5, 2, 36, 36, 41, 41, 94, 94, 5, 2, 78, 78, 87, 87, 119, 119, 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, 642, 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, 125, 3, 2, 2, 2, 2, 127, 3, 2, 2, 2, 3, 129, 3, 2, 2,
+	2, 5, 131, 3, 2, 2, 2, 7, 133, 3, 2, 2, 2, 9, 135, 3, 2, 2, 2, 11, 137,
+	3, 2, 2, 2, 13, 139, 3, 2, 2, 2, 15, 141, 3, 2, 2, 2, 17, 144, 3, 2, 2,
+	2, 19, 146, 3, 2, 2, 2, 21, 149, 3, 2, 2, 2, 23, 152, 3, 2, 2, 2, 25, 163,
+	3, 2, 2, 2, 27, 177, 3, 2, 2, 2, 29, 179, 3, 2, 2, 2, 31, 181, 3, 2, 2,
+	2, 33, 183, 3, 2, 2, 2, 35, 185, 3, 2, 2, 2, 37, 187, 3, 2, 2, 2, 39, 189,
+	3, 2, 2, 2, 41, 192, 3, 2, 2, 2, 43, 195, 3, 2, 2, 2, 45, 198, 3, 2, 2,
+	2, 47, 200, 3, 2, 2, 2, 49, 202, 3, 2, 2, 2, 51, 209, 3, 2, 2, 2, 53, 215,
+	3, 2, 2, 2, 55, 217, 3, 2, 2, 2, 57, 223, 3, 2, 2, 2, 59, 225, 3, 2, 2,
+	2, 61, 228, 3, 2, 2, 2, 63, 235, 3, 2, 2, 2, 65, 271, 3, 2, 2, 2, 67, 307,
+	3, 2, 2, 2, 69, 343, 3, 2, 2, 2, 71, 372, 3, 2, 2, 2, 73, 378, 3, 2, 2,
+	2, 75, 382, 3, 2, 2, 2, 77, 397, 3, 2, 2, 2, 79, 440, 3, 2, 2, 2, 81, 442,
+	3, 2, 2, 2, 83, 457, 3, 2, 2, 2, 85, 459, 3, 2, 2, 2, 87, 461, 3, 2, 2,
+	2, 89, 463, 3, 2, 2, 2, 91, 478, 3, 2, 2, 2, 93, 480, 3, 2, 2, 2, 95, 487,
+	3, 2, 2, 2, 97, 491, 3, 2, 2, 2, 99, 493, 3, 2, 2, 2, 101, 495, 3, 2, 2,
+	2, 103, 497, 3, 2, 2, 2, 105, 512, 3, 2, 2, 2, 107, 521, 3, 2, 2, 2, 109,
+	523, 3, 2, 2, 2, 111, 539, 3, 2, 2, 2, 113, 541, 3, 2, 2, 2, 115, 548,
+	3, 2, 2, 2, 117, 560, 3, 2, 2, 2, 119, 563, 3, 2, 2, 2, 121, 567, 3, 2,
+	2, 2, 123, 588, 3, 2, 2, 2, 125, 591, 3, 2, 2, 2, 127, 602, 3, 2, 2, 2,
+	129, 130, 7, 42, 2, 2, 130, 4, 3, 2, 2, 2, 131, 132, 7, 43, 2, 2, 132,
+	6, 3, 2, 2, 2, 133, 134, 7, 93, 2, 2, 134, 8, 3, 2, 2, 2, 135, 136, 7,
+	46, 2, 2, 136, 10, 3, 2, 2, 2, 137, 138, 7, 95, 2, 2, 138, 12, 3, 2, 2,
+	2, 139, 140, 7, 62, 2, 2, 140, 14, 3, 2, 2, 2, 141, 142, 7, 62, 2, 2, 142,
+	143, 7, 63, 2, 2, 143, 16, 3, 2, 2, 2, 144, 145, 7, 64, 2, 2, 145, 18,
+	3, 2, 2, 2, 146, 147, 7, 64, 2, 2, 147, 148, 7, 63, 2, 2, 148, 20, 3, 2,
+	2, 2, 149, 150, 7, 63, 2, 2, 150, 151, 7, 63, 2, 2, 151, 22, 3, 2, 2, 2,
+	152, 153, 7, 35, 2, 2, 153, 154, 7, 63, 2, 2, 154, 24, 3, 2, 2, 2, 155,
+	156, 7, 110, 2, 2, 156, 157, 7, 107, 2, 2, 157, 158, 7, 109, 2, 2, 158,
+	164, 7, 103, 2, 2, 159, 160, 7, 78, 2, 2, 160, 161, 7, 75, 2, 2, 161, 162,
+	7, 77, 2, 2, 162, 164, 7, 71, 2, 2, 163, 155, 3, 2, 2, 2, 163, 159, 3,
+	2, 2, 2, 164, 26, 3, 2, 2, 2, 165, 166, 7, 103, 2, 2, 166, 167, 7, 122,
+	2, 2, 167, 168, 7, 107, 2, 2, 168, 169, 7, 117, 2, 2, 169, 170, 7, 118,
+	2, 2, 170, 178, 7, 117, 2, 2, 171, 172, 7, 71, 2, 2, 172, 173, 7, 90, 2,
+	2, 173, 174, 7, 75, 2, 2, 174, 175, 7, 85, 2, 2, 175, 176, 7, 86, 2, 2,
+	176, 178, 7, 85, 2, 2, 177, 165, 3, 2, 2, 2, 177, 171, 3, 2, 2, 2, 178,
+	28, 3, 2, 2, 2, 179, 180, 7, 45, 2, 2, 180, 30, 3, 2, 2, 2, 181, 182, 7,
+	47, 2, 2, 182, 32, 3, 2, 2, 2, 183, 184, 7, 44, 2, 2, 184, 34, 3, 2, 2,
+	2, 185, 186, 7, 49, 2, 2, 186, 36, 3, 2, 2, 2, 187, 188, 7, 39, 2, 2, 188,
+	38, 3, 2, 2, 2, 189, 190, 7, 44, 2, 2, 190, 191, 7, 44, 2, 2, 191, 40,
+	3, 2, 2, 2, 192, 193, 7, 62, 2, 2, 193, 194, 7, 62, 2, 2, 194, 42, 3, 2,
+	2, 2, 195, 196, 7, 64, 2, 2, 196, 197, 7, 64, 2, 2, 197, 44, 3, 2, 2, 2,
+	198, 199, 7, 40, 2, 2, 199, 46, 3, 2, 2, 2, 200, 201, 7, 126, 2, 2, 201,
+	48, 3, 2, 2, 2, 202, 203, 7, 96, 2, 2, 203, 50, 3, 2, 2, 2, 204, 205, 7,
+	40, 2, 2, 205, 210, 7, 40, 2, 2, 206, 207, 7, 99, 2, 2, 207, 208, 7, 112,
+	2, 2, 208, 210, 7, 102, 2, 2, 209, 204, 3, 2, 2, 2, 209, 206, 3, 2, 2,
+	2, 210, 52, 3, 2, 2, 2, 211, 212, 7, 126, 2, 2, 212, 216, 7, 126, 2, 2,
+	213, 214, 7, 113, 2, 2, 214, 216, 7, 116, 2, 2, 215, 211, 3, 2, 2, 2, 215,
+	213, 3, 2, 2, 2, 216, 54, 3, 2, 2, 2, 217, 218, 7, 128, 2, 2, 218, 56,
+	3, 2, 2, 2, 219, 224, 7, 35, 2, 2, 220, 221, 7, 112, 2, 2, 221, 222, 7,
+	113, 2, 2, 222, 224, 7, 118, 2, 2, 223, 219, 3, 2, 2, 2, 223, 220, 3, 2,
+	2, 2, 224, 58, 3, 2, 2, 2, 225, 226, 7, 107, 2, 2, 226, 227, 7, 112, 2,
+	2, 227, 60, 3, 2, 2, 2, 228, 229, 7, 112, 2, 2, 229, 230, 7, 113, 2, 2,
+	230, 231, 7, 118, 2, 2, 231, 232, 7, 34, 2, 2, 232, 233, 7, 107, 2, 2,
+	233, 234, 7, 112, 2, 2, 234, 62, 3, 2, 2, 2, 235, 240, 7, 93, 2, 2, 236,
+	239, 5, 125, 63, 2, 237, 239, 5, 127, 64, 2, 238, 236, 3, 2, 2, 2, 238,
+	237, 3, 2, 2, 2, 239, 242, 3, 2, 2, 2, 240, 238, 3, 2, 2, 2, 240, 241,
+	3, 2, 2, 2, 241, 243, 3, 2, 2, 2, 242, 240, 3, 2, 2, 2, 243, 244, 7, 95,
+	2, 2, 244, 64, 3, 2, 2, 2, 245, 246, 7, 108, 2, 2, 246, 247, 7, 117, 2,
+	2, 247, 248, 7, 113, 2, 2, 248, 249, 7, 112, 2, 2, 249, 250, 7, 97, 2,
+	2, 250, 251, 7, 101, 2, 2, 251, 252, 7, 113, 2, 2, 252, 253, 7, 112, 2,
+	2, 253, 254, 7, 118, 2, 2, 254, 255, 7, 99, 2, 2, 255, 256, 7, 107, 2,
+	2, 256, 257, 7, 112, 2, 2, 257, 272, 7, 117, 2, 2, 258, 259, 7, 76, 2,
+	2, 259, 260, 7, 85, 2, 2, 260, 261, 7, 81, 2, 2, 261, 262, 7, 80, 2, 2,
+	262, 263, 7, 97, 2, 2, 263, 264, 7, 69, 2, 2, 264, 265, 7, 81, 2, 2, 265,
+	266, 7, 80, 2, 2, 266, 267, 7, 86, 2, 2, 267, 268, 7, 67, 2, 2, 268, 269,
+	7, 75, 2, 2, 269, 270, 7, 80, 2, 2, 270, 272, 7, 85, 2, 2, 271, 245, 3,
+	2, 2, 2, 271, 258, 3, 2, 2, 2, 272, 66, 3, 2, 2, 2, 273, 274, 7, 108, 2,
+	2, 274, 275, 7, 117, 2, 2, 275, 276, 7, 113, 2, 2, 276, 277, 7, 112, 2,
+	2, 277, 278, 7, 97, 2, 2, 278, 279, 7, 101, 2, 2, 279, 280, 7, 113, 2,
+	2, 280, 281, 7, 112, 2, 2, 281, 282, 7, 118, 2, 2, 282, 283, 7, 99, 2,
+	2, 283, 284, 7, 107, 2, 2, 284, 285, 7, 112, 2, 2, 285, 286, 7, 117, 2,
+	2, 286, 287, 7, 97, 2, 2, 287, 288, 7, 99, 2, 2, 288, 289, 7, 110, 2, 2,
+	289, 308, 7, 110, 2, 2, 290, 291, 7, 76, 2, 2, 291, 292, 7, 85, 2, 2, 292,
+	293, 7, 81, 2, 2, 293, 294, 7, 80, 2, 2, 294, 295, 7, 97, 2, 2, 295, 296,
+	7, 69, 2, 2, 296, 297, 7, 81, 2, 2, 297, 298, 7, 80, 2, 2, 298, 299, 7,
+	86, 2, 2, 299, 300, 7, 67, 2, 2, 300, 301, 7, 75, 2, 2, 301, 302, 7, 80,
+	2, 2, 302, 303, 7, 85, 2, 2, 303, 304, 7, 97, 2, 2, 304, 305, 7, 67, 2,
+	2, 305, 306, 7, 78, 2, 2, 306, 308, 7, 78, 2, 2, 307, 273, 3, 2, 2, 2,
+	307, 290, 3, 2, 2, 2, 308, 68, 3, 2, 2, 2, 309, 310, 7, 108, 2, 2, 310,
+	311, 7, 117, 2, 2, 311, 312, 7, 113, 2, 2, 312, 313, 7, 112, 2, 2, 313,
+	314, 7, 97, 2, 2, 314, 315, 7, 101, 2, 2, 315, 316, 7, 113, 2, 2, 316,
+	317, 7, 112, 2, 2, 317, 318, 7, 118, 2, 2, 318, 319, 7, 99, 2, 2, 319,
+	320, 7, 107, 2, 2, 320, 321, 7, 112, 2, 2, 321, 322, 7, 117, 2, 2, 322,
+	323, 7, 97, 2, 2, 323, 324, 7, 99, 2, 2, 324, 325, 7, 112, 2, 2, 325, 344,
+	7, 123, 2, 2, 326, 327, 7, 76, 2, 2, 327, 328, 7, 85, 2, 2, 328, 329, 7,
+	81, 2, 2, 329, 330, 7, 80, 2, 2, 330, 331, 7, 97, 2, 2, 331, 332, 7, 69,
+	2, 2, 332, 333, 7, 81, 2, 2, 333, 334, 7, 80, 2, 2, 334, 335, 7, 86, 2,
+	2, 335, 336, 7, 67, 2, 2, 336, 337, 7, 75, 2, 2, 337, 338, 7, 80, 2, 2,
+	338, 339, 7, 85, 2, 2, 339, 340, 7, 97, 2, 2, 340, 341, 7, 67, 2, 2, 341,
+	342, 7, 80, 2, 2, 342, 344, 7, 91, 2, 2, 343, 309, 3, 2, 2, 2, 343, 326,
+	3, 2, 2, 2, 344, 70, 3, 2, 2, 2, 345, 346, 7, 118, 2, 2, 346, 347, 7, 116,
+	2, 2, 347, 348, 7, 119, 2, 2, 348, 373, 7, 103, 2, 2, 349, 350, 7, 86,
+	2, 2, 350, 351, 7, 116, 2, 2, 351, 352, 7, 119, 2, 2, 352, 373, 7, 103,
+	2, 2, 353, 354, 7, 86, 2, 2, 354, 355, 7, 84, 2, 2, 355, 356, 7, 87, 2,
+	2, 356, 373, 7, 71, 2, 2, 357, 358, 7, 104, 2, 2, 358, 359, 7, 99, 2, 2,
+	359, 360, 7, 110, 2, 2, 360, 361, 7, 117, 2, 2, 361, 373, 7, 103, 2, 2,
+	362, 363, 7, 72, 2, 2, 363, 364, 7, 99, 2, 2, 364, 365, 7, 110, 2, 2, 365,
+	366, 7, 117, 2, 2, 366, 373, 7, 103, 2, 2, 367, 368, 7, 72, 2, 2, 368,
+	369, 7, 67, 2, 2, 369, 370, 7, 78, 2, 2, 370, 371, 7, 85, 2, 2, 371, 373,
+	7, 71, 2, 2, 372, 345, 3, 2, 2, 2, 372, 349, 3, 2, 2, 2, 372, 353, 3, 2,
+	2, 2, 372, 357, 3, 2, 2, 2, 372, 362, 3, 2, 2, 2, 372, 367, 3, 2, 2, 2,
+	373, 72, 3, 2, 2, 2, 374, 379, 5, 91, 46, 2, 375, 379, 5, 93, 47, 2, 376,
+	379, 5, 95, 48, 2, 377, 379, 5, 89, 45, 2, 378, 374, 3, 2, 2, 2, 378, 375,
+	3, 2, 2, 2, 378, 376, 3, 2, 2, 2, 378, 377, 3, 2, 2, 2, 379, 74, 3, 2,
+	2, 2, 380, 383, 5, 107, 54, 2, 381, 383, 5, 109, 55, 2, 382, 380, 3, 2,
+	2, 2, 382, 381, 3, 2, 2, 2, 383, 76, 3, 2, 2, 2, 384, 389, 5, 85, 43, 2,
+	385, 388, 5, 85, 43, 2, 386, 388, 5, 87, 44, 2, 387, 385, 3, 2, 2, 2, 387,
+	386, 3, 2, 2, 2, 388, 391, 3, 2, 2, 2, 389, 387, 3, 2, 2, 2, 389, 390,
+	3, 2, 2, 2, 390, 398, 3, 2, 2, 2, 391, 389, 3, 2, 2, 2, 392, 393, 7, 38,
+	2, 2, 393, 394, 7, 111, 2, 2, 394, 395, 7, 103, 2, 2, 395, 396, 7, 118,
+	2, 2, 396, 398, 7, 99, 2, 2, 397, 384, 3, 2, 2, 2, 397, 392, 3, 2, 2, 2,
+	398, 78, 3, 2, 2, 2, 399, 401, 5, 83, 42, 2, 400, 399, 3, 2, 2, 2, 400,
+	401, 3, 2, 2, 2, 401, 402, 3, 2, 2, 2, 402, 403, 7, 36, 2, 2, 403, 415,
+	8, 40, 2, 2, 404, 409, 7, 94, 2, 2, 405, 406, 7, 41, 2, 2, 406, 410, 8,
+	40, 3, 2, 407, 408, 10, 2, 2, 2, 408, 410, 8, 40, 4, 2, 409, 405, 3, 2,
+	2, 2, 409, 407, 3, 2, 2, 2, 410, 414, 3, 2, 2, 2, 411, 412, 10, 3, 2, 2,
+	412, 414, 8, 40, 5, 2, 413, 404, 3, 2, 2, 2, 413, 411, 3, 2, 2, 2, 414,
+	417, 3, 2, 2, 2, 415, 413, 3, 2, 2, 2, 415, 416, 3, 2, 2, 2, 416, 418,
+	3, 2, 2, 2, 417, 415, 3, 2, 2, 2, 418, 419, 7, 36, 2, 2, 419, 441, 8, 40,
+	6, 2, 420, 421, 7, 41, 2, 2, 421, 435, 8, 40, 7, 2, 422, 427, 7, 94, 2,
+	2, 423, 424, 7, 41, 2, 2, 424, 428, 8, 40, 8, 2, 425, 426, 10, 2, 2, 2,
+	426, 428, 8, 40, 9, 2, 427, 423, 3, 2, 2, 2, 427, 425, 3, 2, 2, 2, 428,
+	434, 3, 2, 2, 2, 429, 430, 7, 36, 2, 2, 430, 434, 8, 40, 10, 2, 431, 432,
+	10, 4, 2, 2, 432, 434, 8, 40, 11, 2, 433, 422, 3, 2, 2, 2, 433, 429, 3,
+	2, 2, 2, 433, 431, 3, 2, 2, 2, 434, 437, 3, 2, 2, 2, 435, 433, 3, 2, 2,
+	2, 435, 436, 3, 2, 2, 2, 436, 438, 3, 2, 2, 2, 437, 435, 3, 2, 2, 2, 438,
+	439, 7, 41, 2, 2, 439, 441, 8, 40, 12, 2, 440, 400, 3, 2, 2, 2, 440, 420,
+	3, 2, 2, 2, 441, 80, 3, 2, 2, 2, 442, 450, 5, 77, 39, 2, 443, 446, 7, 93,
+	2, 2, 444, 447, 5, 79, 40, 2, 445, 447, 5, 91, 46, 2, 446, 444, 3, 2, 2,
+	2, 446, 445, 3, 2, 2, 2, 447, 448, 3, 2, 2, 2, 448, 449, 7, 95, 2, 2, 449,
+	451, 3, 2, 2, 2, 450, 443, 3, 2, 2, 2, 451, 452, 3, 2, 2, 2, 452, 450,
+	3, 2, 2, 2, 452, 453, 3, 2, 2, 2, 453, 82, 3, 2, 2, 2, 454, 455, 7, 119,
+	2, 2, 455, 458, 7, 58, 2, 2, 456, 458, 9, 5, 2, 2, 457, 454, 3, 2, 2, 2,
+	457, 456, 3, 2, 2, 2, 458, 84, 3, 2, 2, 2, 459, 460, 9, 6, 2, 2, 460, 86,
+	3, 2, 2, 2, 461, 462, 9, 7, 2, 2, 462, 88, 3, 2, 2, 2, 463, 464, 7, 50,
+	2, 2, 464, 466, 9, 8, 2, 2, 465, 467, 9, 9, 2, 2, 466, 465, 3, 2, 2, 2,
+	467, 468, 3, 2, 2, 2, 468, 466, 3, 2, 2, 2, 468, 469, 3, 2, 2, 2, 469,
+	90, 3, 2, 2, 2, 470, 474, 5, 97, 49, 2, 471, 473, 5, 87, 44, 2, 472, 471,
+	3, 2, 2, 2, 473, 476, 3, 2, 2, 2, 474, 472, 3, 2, 2, 2, 474, 475, 3, 2,
+	2, 2, 475, 479, 3, 2, 2, 2, 476, 474, 3, 2, 2, 2, 477, 479, 7, 50, 2, 2,
+	478, 470, 3, 2, 2, 2, 478, 477, 3, 2, 2, 2, 479, 92, 3, 2, 2, 2, 480, 484,
+	7, 50, 2, 2, 481, 483, 5, 99, 50, 2, 482, 481, 3, 2, 2, 2, 483, 486, 3,
+	2, 2, 2, 484, 482, 3, 2, 2, 2, 484, 485, 3, 2, 2, 2, 485, 94, 3, 2, 2,
+	2, 486, 484, 3, 2, 2, 2, 487, 488, 7, 50, 2, 2, 488, 489, 9, 10, 2, 2,
+	489, 490, 5, 119, 60, 2, 490, 96, 3, 2, 2, 2, 491, 492, 9, 11, 2, 2, 492,
+	98, 3, 2, 2, 2, 493, 494, 9, 12, 2, 2, 494, 100, 3, 2, 2, 2, 495, 496,
+	9, 13, 2, 2, 496, 102, 3, 2, 2, 2, 497, 498, 5, 101, 51, 2, 498, 499, 5,
+	101, 51, 2, 499, 500, 5, 101, 51, 2, 500, 501, 5, 101, 51, 2, 501, 104,
+	3, 2, 2, 2, 502, 503, 7, 94, 2, 2, 503, 504, 7, 119, 2, 2, 504, 505, 3,
+	2, 2, 2, 505, 513, 5, 103, 52, 2, 506, 507, 7, 94, 2, 2, 507, 508, 7, 87,
+	2, 2, 508, 509, 3, 2, 2, 2, 509, 510, 5, 103, 52, 2, 510, 511, 5, 103,
+	52, 2, 511, 513, 3, 2, 2, 2, 512, 502, 3, 2, 2, 2, 512, 506, 3, 2, 2, 2,
+	513, 106, 3, 2, 2, 2, 514, 516, 5, 111, 56, 2, 515, 517, 5, 113, 57, 2,
+	516, 515, 3, 2, 2, 2, 516, 517, 3, 2, 2, 2, 517, 522, 3, 2, 2, 2, 518,
+	519, 5, 115, 58, 2, 519, 520, 5, 113, 57, 2, 520, 522, 3, 2, 2, 2, 521,
+	514, 3, 2, 2, 2, 521, 518, 3, 2, 2, 2, 522, 108, 3, 2, 2, 2, 523, 524,
+	7, 50, 2, 2, 524, 527, 9, 10, 2, 2, 525, 528, 5, 117, 59, 2, 526, 528,
+	5, 119, 60, 2, 527, 525, 3, 2, 2, 2, 527, 526, 3, 2, 2, 2, 528, 529, 3,
+	2, 2, 2, 529, 530, 5, 121, 61, 2, 530, 110, 3, 2, 2, 2, 531, 533, 5, 115,
+	58, 2, 532, 531, 3, 2, 2, 2, 532, 533, 3, 2, 2, 2, 533, 534, 3, 2, 2, 2,
+	534, 535, 7, 48, 2, 2, 535, 540, 5, 115, 58, 2, 536, 537, 5, 115, 58, 2,
+	537, 538, 7, 48, 2, 2, 538, 540, 3, 2, 2, 2, 539, 532, 3, 2, 2, 2, 539,
+	536, 3, 2, 2, 2, 540, 112, 3, 2, 2, 2, 541, 543, 9, 14, 2, 2, 542, 544,
+	9, 15, 2, 2, 543, 542, 3, 2, 2, 2, 543, 544, 3, 2, 2, 2, 544, 545, 3, 2,
+	2, 2, 545, 546, 5, 115, 58, 2, 546, 114, 3, 2, 2, 2, 547, 549, 5, 87, 44,
+	2, 548, 547, 3, 2, 2, 2, 549, 550, 3, 2, 2, 2, 550, 548, 3, 2, 2, 2, 550,
+	551, 3, 2, 2, 2, 551, 116, 3, 2, 2, 2, 552, 554, 5, 119, 60, 2, 553, 552,
+	3, 2, 2, 2, 553, 554, 3, 2, 2, 2, 554, 555, 3, 2, 2, 2, 555, 556, 7, 48,
+	2, 2, 556, 561, 5, 119, 60, 2, 557, 558, 5, 119, 60, 2, 558, 559, 7, 48,
+	2, 2, 559, 561, 3, 2, 2, 2, 560, 553, 3, 2, 2, 2, 560, 557, 3, 2, 2, 2,
+	561, 118, 3, 2, 2, 2, 562, 564, 5, 101, 51, 2, 563, 562, 3, 2, 2, 2, 564,
+	565, 3, 2, 2, 2, 565, 563, 3, 2, 2, 2, 565, 566, 3, 2, 2, 2, 566, 120,
+	3, 2, 2, 2, 567, 569, 9, 16, 2, 2, 568, 570, 9, 15, 2, 2, 569, 568, 3,
+	2, 2, 2, 569, 570, 3, 2, 2, 2, 570, 571, 3, 2, 2, 2, 571, 572, 5, 115,
+	58, 2, 572, 122, 3, 2, 2, 2, 573, 574, 7, 94, 2, 2, 574, 589, 9, 17, 2,
+	2, 575, 576, 7, 94, 2, 2, 576, 578, 5, 99, 50, 2, 577, 579, 5, 99, 50,
+	2, 578, 577, 3, 2, 2, 2, 578, 579, 3, 2, 2, 2, 579, 581, 3, 2, 2, 2, 580,
+	582, 5, 99, 50, 2, 581, 580, 3, 2, 2, 2, 581, 582, 3, 2, 2, 2, 582, 589,
+	3, 2, 2, 2, 583, 584, 7, 94, 2, 2, 584, 585, 7, 122, 2, 2, 585, 586, 3,
+	2, 2, 2, 586, 589, 5, 119, 60, 2, 587, 589, 5, 105, 53, 2, 588, 573, 3,
+	2, 2, 2, 588, 575, 3, 2, 2, 2, 588, 583, 3, 2, 2, 2, 588, 587, 3, 2, 2,
+	2, 589, 124, 3, 2, 2, 2, 590, 592, 9, 18, 2, 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, 595,
+	3, 2, 2, 2, 595, 596, 8, 63, 13, 2, 596, 126, 3, 2, 2, 2, 597, 599, 7,
+	15, 2, 2, 598, 600, 7, 12, 2, 2, 599, 598, 3, 2, 2, 2, 599, 600, 3, 2,
+	2, 2, 600, 603, 3, 2, 2, 2, 601, 603, 7, 12, 2, 2, 602, 597, 3, 2, 2, 2,
+	602, 601, 3, 2, 2, 2, 603, 604, 3, 2, 2, 2, 604, 605, 8, 64, 13, 2, 605,
+	128, 3, 2, 2, 2, 52, 2, 163, 177, 209, 215, 223, 238, 240, 271, 307, 343,
+	372, 378, 382, 387, 389, 397, 400, 409, 413, 415, 427, 433, 435, 440, 446,
+	452, 457, 468, 474, 478, 484, 512, 516, 521, 527, 532, 539, 543, 550, 553,
+	560, 565, 569, 578, 581, 588, 593, 599, 602, 14, 3, 40, 2, 3, 40, 3, 3,
+	40, 4, 3, 40, 5, 3, 40, 6, 3, 40, 7, 3, 40, 8, 3, 40, 9, 3, 40, 10, 3,
+	40, 11, 3, 40, 12, 8, 2, 2,
 }
 
 var lexerChannelNames = []string{
@@ -281,21 +314,23 @@ 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",
-	"BooleanConstant", "IntegerConstant", "FloatingConstant", "Identifier",
-	"StringLiteral", "JSONIdentifier", "Whitespace", "Newline",
+	"JSONContainsAll", "JSONContainsAny", "BooleanConstant", "IntegerConstant",
+	"FloatingConstant", "Identifier", "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", "BooleanConstant", "IntegerConstant", "FloatingConstant",
-	"Identifier", "StringLiteral", "JSONIdentifier", "EncodingPrefix", "Nondigit",
-	"Digit", "BinaryConstant", "DecimalConstant", "OctalConstant", "HexadecimalConstant",
-	"NonzeroDigit", "OctalDigit", "HexadecimalDigit", "HexQuad", "UniversalCharacterName",
-	"DecimalFloatingConstant", "HexadecimalFloatingConstant", "FractionalConstant",
-	"ExponentPart", "DigitSequence", "HexadecimalFractionalConstant", "HexadecimalDigitSequence",
-	"BinaryExponentPart", "EscapeSequence", "Whitespace", "Newline",
+	"JSONContains", "JSONContainsAll", "JSONContainsAny", "BooleanConstant",
+	"IntegerConstant", "FloatingConstant", "Identifier", "StringLiteral", "JSONIdentifier",
+	"EncodingPrefix", "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 {
@@ -367,21 +402,23 @@ const (
 	PlanLexerNIN              = 30
 	PlanLexerEmptyTerm        = 31
 	PlanLexerJSONContains     = 32
-	PlanLexerBooleanConstant  = 33
-	PlanLexerIntegerConstant  = 34
-	PlanLexerFloatingConstant = 35
-	PlanLexerIdentifier       = 36
-	PlanLexerStringLiteral    = 37
-	PlanLexerJSONIdentifier   = 38
-	PlanLexerWhitespace       = 39
-	PlanLexerNewline          = 40
+	PlanLexerJSONContainsAll  = 33
+	PlanLexerJSONContainsAny  = 34
+	PlanLexerBooleanConstant  = 35
+	PlanLexerIntegerConstant  = 36
+	PlanLexerFloatingConstant = 37
+	PlanLexerIdentifier       = 38
+	PlanLexerStringLiteral    = 39
+	PlanLexerJSONIdentifier   = 40
+	PlanLexerWhitespace       = 41
+	PlanLexerNewline          = 42
 )
 
 var str = ""
 
 func (l *PlanLexer) Action(localctx antlr.RuleContext, ruleIndex, actionIndex int) {
 	switch ruleIndex {
-	case 36:
+	case 38:
 		l.StringLiteral_Action(localctx, actionIndex)
 
 	default:

internal/parser/planparserv2/generated/plan_visitor.go

@@ -19,6 +19,9 @@ type PlanVisitor interface {
 	// Visit a parse tree produced by PlanParser#Floating.
 	VisitFloating(ctx *FloatingContext) interface{}
 
+	// Visit a parse tree produced by PlanParser#JSONContainsAll.
+	VisitJSONContainsAll(ctx *JSONContainsAllContext) interface{}
+
 	// Visit a parse tree produced by PlanParser#LogicalOr.
 	VisitLogicalOr(ctx *LogicalOrContext) interface{}
 
@@ -70,6 +73,12 @@ type PlanVisitor interface {
 	// Visit a parse tree produced by PlanParser#Integer.
 	VisitInteger(ctx *IntegerContext) interface{}
 
+	// Visit a parse tree produced by PlanParser#Array.
+	VisitArray(ctx *ArrayContext) interface{}
+
+	// Visit a parse tree produced by PlanParser#JSONContainsAny.
+	VisitJSONContainsAny(ctx *JSONContainsAnyContext) interface{}
+
 	// Visit a parse tree produced by PlanParser#BitXor.
 	VisitBitXor(ctx *BitXorContext) interface{}
 

internal/parser/planparserv2/parser_visitor.go

@@ -961,6 +961,9 @@ func (v *ParserVisitor) getColumnInfoFromJSONIdentifier(identifier string) (*pla
 		if (strings.HasPrefix(path, "\"") && strings.HasSuffix(path, "\"")) ||
 			(strings.HasPrefix(path, "'") && strings.HasSuffix(path, "'")) {
 			path = path[1 : len(path)-1]
+			if path == "" {
+				return nil, fmt.Errorf("invalid identifier: %s", identifier)
+			}
 		} else if _, err := strconv.ParseInt(path, 10, 64); err != nil {
 			return nil, fmt.Errorf("json key must be enclosed in double quotes or single quotes: \"%s\"", path)
 		}
@@ -1052,14 +1055,142 @@ func (v *ParserVisitor) VisitJSONContains(ctx *parser.JSONContainsContext) inter
 			"json_contains operation are only supported explicitly specified element, got: %s", ctx.Expr(1).GetText())
 	}
 
-	values := make([]*planpb.GenericValue, 1)
-	values[0] = elementValue
+	elements := make([]*planpb.GenericValue, 1)
+	elements[0] = elementValue
+
 	expr := &planpb.Expr{
-		Expr: &planpb.Expr_TermExpr{
-			TermExpr: &planpb.TermExpr{
-				ColumnInfo: columnInfo,
-				Values:     values,
-				IsInField:  true,
+		Expr: &planpb.Expr_JsonContainsExpr{
+			JsonContainsExpr: &planpb.JSONContainsExpr{
+				ColumnInfo:       columnInfo,
+				Elements:         elements,
+				Op:               planpb.JSONContainsExpr_Contains,
+				ElementsSameType: true,
+			},
+		},
+	}
+	return &ExprWithType{
+		expr:     expr,
+		dataType: schemapb.DataType_Bool,
+	}
+}
+
+func (v *ParserVisitor) VisitArray(ctx *parser.ArrayContext) interface{} {
+	allExpr := ctx.AllExpr()
+	array := make([]*planpb.GenericValue, 0, len(allExpr))
+	dType := schemapb.DataType_None
+	sameType := true
+	for i := 0; i < len(allExpr); i++ {
+		element := allExpr[i].Accept(v)
+		if err := getError(element); err != nil {
+			return err
+		}
+		elementValue := getGenericValue(element)
+		if elementValue == nil {
+			return fmt.Errorf("array element type must be generic value, but got: %s", allExpr[i].GetText())
+		}
+		array = append(array, getGenericValue(element))
+
+		if dType == schemapb.DataType_None {
+			dType = element.(*ExprWithType).dataType
+		} else if dType != element.(*ExprWithType).dataType {
+			sameType = false
+		}
+	}
+
+	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:    array,
+								SameType: sameType,
+							},
+						},
+					},
+				},
+			},
+		},
+	}
+}
+
+func (v *ParserVisitor) VisitJSONContainsAll(ctx *parser.JSONContainsAllContext) interface{} {
+	field := ctx.Expr(0).Accept(v)
+	if err := getError(field); err != nil {
+		return err
+	}
+
+	columnInfo := toColumnInfo(field.(*ExprWithType))
+	if columnInfo == nil || !typeutil.IsJSONType(columnInfo.GetDataType()) {
+		return fmt.Errorf(
+			"json_contains_all operation are only supported on json fields now, got: %s", ctx.Expr(0).GetText())
+	}
+
+	element := ctx.Expr(1).Accept(v)
+	if err := getError(element); err != nil {
+		return err
+	}
+	elementValue := getGenericValue(element)
+	if elementValue == nil {
+		return fmt.Errorf(
+			"json_contains_all operation are only supported explicitly specified element, got: %s", ctx.Expr(1).GetText())
+	}
+
+	if elementValue.GetArrayVal() == nil {
+		return fmt.Errorf("json_contains_all operation element must be an array")
+	}
+
+	expr := &planpb.Expr{
+		Expr: &planpb.Expr_JsonContainsExpr{
+			JsonContainsExpr: &planpb.JSONContainsExpr{
+				ColumnInfo:       columnInfo,
+				Elements:         elementValue.GetArrayVal().GetArray(),
+				Op:               planpb.JSONContainsExpr_ContainsAll,
+				ElementsSameType: elementValue.GetArrayVal().GetSameType(),
+			},
+		},
+	}
+	return &ExprWithType{
+		expr:     expr,
+		dataType: schemapb.DataType_Bool,
+	}
+}
+
+func (v *ParserVisitor) VisitJSONContainsAny(ctx *parser.JSONContainsAnyContext) interface{} {
+	field := ctx.Expr(0).Accept(v)
+	if err := getError(field); err != nil {
+		return err
+	}
+
+	columnInfo := toColumnInfo(field.(*ExprWithType))
+	if columnInfo == nil || !typeutil.IsJSONType(columnInfo.GetDataType()) {
+		return fmt.Errorf(
+			"json_contains_any operation are only supported on json fields now, got: %s", ctx.Expr(0).GetText())
+	}
+
+	element := ctx.Expr(1).Accept(v)
+	if err := getError(element); err != nil {
+		return err
+	}
+	elementValue := getGenericValue(element)
+	if elementValue == nil {
+		return fmt.Errorf(
+			"json_contains_any operation are only supported explicitly specified element, got: %s", ctx.Expr(1).GetText())
+	}
+
+	if elementValue.GetArrayVal() == nil {
+		return fmt.Errorf("json_contains_any operation element must be an array")
+	}
+
+	expr := &planpb.Expr{
+		Expr: &planpb.Expr_JsonContainsExpr{
+			JsonContainsExpr: &planpb.JSONContainsExpr{
+				ColumnInfo:       columnInfo,
+				Elements:         elementValue.GetArrayVal().GetArray(),
+				Op:               planpb.JSONContainsExpr_ContainsAny,
+				ElementsSameType: elementValue.GetArrayVal().GetSameType(),
 			},
 		},
 	}

internal/parser/planparserv2/plan_parser_v2_test.go

@@ -1293,7 +1293,7 @@ func Test_JSONContains(t *testing.T) {
 		RoundDecimal: 0,
 	})
 	assert.NoError(t, err)
-	assert.NotNil(t, plan.GetVectorAnns().GetPredicates().GetTermExpr())
+	assert.NotNil(t, plan.GetVectorAnns().GetPredicates().GetJsonContainsExpr())
 
 	expr = `not json_contains(A, 10)`
 	plan, err = CreateSearchPlan(schema, expr, "FloatVectorField", &planpb.QueryInfo{
@@ -1313,7 +1313,7 @@ func Test_JSONContains(t *testing.T) {
 		RoundDecimal: 0,
 	})
 	assert.NoError(t, err)
-	assert.NotNil(t, plan.GetVectorAnns().GetPredicates().GetTermExpr())
+	assert.NotNil(t, plan.GetVectorAnns().GetPredicates().GetJsonContainsExpr())
 
 	expr = `not json_contains(A, 10.5)`
 	plan, err = CreateSearchPlan(schema, expr, "FloatVectorField", &planpb.QueryInfo{
@@ -1333,7 +1333,7 @@ func Test_JSONContains(t *testing.T) {
 		RoundDecimal: 0,
 	})
 	assert.NoError(t, err)
-	assert.NotNil(t, plan.GetVectorAnns().GetPredicates().GetTermExpr())
+	assert.NotNil(t, plan.GetVectorAnns().GetPredicates().GetJsonContainsExpr())
 
 	expr = `not json_contains(A, "10")`
 	plan, err = CreateSearchPlan(schema, expr, "FloatVectorField", &planpb.QueryInfo{
@@ -1353,7 +1353,7 @@ func Test_JSONContains(t *testing.T) {
 		RoundDecimal: 0,
 	})
 	assert.NoError(t, err)
-	assert.NotNil(t, plan.GetVectorAnns().GetPredicates().GetTermExpr())
+	assert.NotNil(t, plan.GetVectorAnns().GetPredicates().GetJsonContainsExpr())
 
 	expr = `not json_contains($meta["A"], 10)`
 	plan, err = CreateSearchPlan(schema, expr, "FloatVectorField", &planpb.QueryInfo{
@@ -1373,7 +1373,7 @@ func Test_JSONContains(t *testing.T) {
 		RoundDecimal: 0,
 	})
 	assert.NoError(t, err)
-	assert.NotNil(t, plan.GetVectorAnns().GetPredicates().GetTermExpr())
+	assert.NotNil(t, plan.GetVectorAnns().GetPredicates().GetJsonContainsExpr())
 
 	expr = `not json_contains(JSONField["x"], 5)`
 	plan, err = CreateSearchPlan(schema, expr, "FloatVectorField", &planpb.QueryInfo{
@@ -1393,7 +1393,17 @@ func Test_JSONContains(t *testing.T) {
 		RoundDecimal: 0,
 	})
 	assert.NoError(t, err)
-	assert.NotNil(t, plan.GetVectorAnns().GetPredicates().GetTermExpr())
+	assert.NotNil(t, plan.GetVectorAnns().GetPredicates().GetJsonContainsExpr())
+
+	expr = `json_contains(A, [1,2,3])`
+	plan, err = CreateSearchPlan(schema, expr, "FloatVectorField", &planpb.QueryInfo{
+		Topk:         0,
+		MetricType:   "",
+		SearchParams: "",
+		RoundDecimal: 0,
+	})
+	assert.NoError(t, err)
+	assert.NotNil(t, plan.GetVectorAnns().GetPredicates().GetJsonContainsExpr())
 }
 
 func Test_InvalidJSONContains(t *testing.T) {
@@ -1445,15 +1455,6 @@ func Test_InvalidJSONContains(t *testing.T) {
 	})
 	assert.Error(t, err)
 
-	expr = `json_contains(A, [1,2,3])`
-	_, err = CreateSearchPlan(schema, expr, "FloatVectorField", &planpb.QueryInfo{
-		Topk:         0,
-		MetricType:   "",
-		SearchParams: "",
-		RoundDecimal: 0,
-	})
-	assert.Error(t, err)
-
 	expr = `json_contains($meta, 1)`
 	_, err = CreateSearchPlan(schema, expr, "FloatVectorField", &planpb.QueryInfo{
 		Topk:         0,
@@ -1685,3 +1686,252 @@ func Test_isEmptyExpression(t *testing.T) {
 		})
 	}
 }
+
+func Test_JSONContainsAll(t *testing.T) {
+	schema := newTestSchema()
+	expr := ""
+	var err error
+	var plan *planpb.PlanNode
+
+	expr = `json_contains_all(A, [1,2,3])`
+	plan, err = CreateSearchPlan(schema, expr, "FloatVectorField", &planpb.QueryInfo{
+		Topk:         0,
+		MetricType:   "",
+		SearchParams: "",
+		RoundDecimal: 0,
+	})
+	assert.NoError(t, err)
+	assert.NotNil(t, plan.GetVectorAnns().GetPredicates().GetJsonContainsExpr())
+	assert.Equal(t, planpb.JSONContainsExpr_ContainsAll, plan.GetVectorAnns().GetPredicates().GetJsonContainsExpr().GetOp())
+	assert.True(t, plan.GetVectorAnns().GetPredicates().GetJsonContainsExpr().GetElementsSameType())
+
+	expr = `json_contains_all(A, [1,"2",3.0])`
+	plan, err = CreateSearchPlan(schema, expr, "FloatVectorField", &planpb.QueryInfo{
+		Topk:         0,
+		MetricType:   "",
+		SearchParams: "",
+		RoundDecimal: 0,
+	})
+	assert.NoError(t, err)
+	assert.NotNil(t, plan.GetVectorAnns().GetPredicates().GetJsonContainsExpr())
+	assert.Equal(t, planpb.JSONContainsExpr_ContainsAll, plan.GetVectorAnns().GetPredicates().GetJsonContainsExpr().GetOp())
+	assert.False(t, plan.GetVectorAnns().GetPredicates().GetJsonContainsExpr().GetElementsSameType())
+
+	expr = `JSON_CONTAINS_ALL(A, [1,"2",3.0])`
+	plan, err = CreateSearchPlan(schema, expr, "FloatVectorField", &planpb.QueryInfo{
+		Topk:         0,
+		MetricType:   "",
+		SearchParams: "",
+		RoundDecimal: 0,
+	})
+	assert.NoError(t, err)
+	assert.NotNil(t, plan.GetVectorAnns().GetPredicates().GetJsonContainsExpr())
+	assert.Equal(t, planpb.JSONContainsExpr_ContainsAll, plan.GetVectorAnns().GetPredicates().GetJsonContainsExpr().GetOp())
+	assert.False(t, plan.GetVectorAnns().GetPredicates().GetJsonContainsExpr().GetElementsSameType())
+}
+
+func Test_InvalidJSONContainsAll(t *testing.T) {
+	schema := newTestSchema()
+	expr := ""
+	var err error
+	var plan *planpb.PlanNode
+
+	expr = `JSON_CONTAINS_ALL(A, 1)`
+	plan, err = CreateSearchPlan(schema, expr, "FloatVectorField", &planpb.QueryInfo{
+		Topk:         0,
+		MetricType:   "",
+		SearchParams: "",
+		RoundDecimal: 0,
+	})
+	assert.Error(t, err)
+	assert.Nil(t, plan)
+
+	expr = `JSON_CONTAINS_ALL(A, [abc])`
+	plan, err = CreateSearchPlan(schema, expr, "FloatVectorField", &planpb.QueryInfo{
+		Topk:         0,
+		MetricType:   "",
+		SearchParams: "",
+		RoundDecimal: 0,
+	})
+	assert.Error(t, err)
+	assert.Nil(t, plan)
+
+	expr = `JSON_CONTAINS_ALL(A, [2>a])`
+	plan, err = CreateSearchPlan(schema, expr, "FloatVectorField", &planpb.QueryInfo{
+		Topk:         0,
+		MetricType:   "",
+		SearchParams: "",
+		RoundDecimal: 0,
+	})
+	assert.Error(t, err)
+	assert.Nil(t, plan)
+
+	expr = `JSON_CONTAINS_ALL(A, [2>>a])`
+	plan, err = CreateSearchPlan(schema, expr, "FloatVectorField", &planpb.QueryInfo{
+		Topk:         0,
+		MetricType:   "",
+		SearchParams: "",
+		RoundDecimal: 0,
+	})
+	assert.Error(t, err)
+	assert.Nil(t, plan)
+
+	expr = `JSON_CONTAINS_ALL(A[""], [1,2,3])`
+	plan, err = CreateSearchPlan(schema, expr, "FloatVectorField", &planpb.QueryInfo{
+		Topk:         0,
+		MetricType:   "",
+		SearchParams: "",
+		RoundDecimal: 0,
+	})
+	assert.Error(t, err)
+	assert.Nil(t, plan)
+
+	expr = `JSON_CONTAINS_ALL(Int64Field, [1,2,3])`
+	plan, err = CreateSearchPlan(schema, expr, "FloatVectorField", &planpb.QueryInfo{
+		Topk:         0,
+		MetricType:   "",
+		SearchParams: "",
+		RoundDecimal: 0,
+	})
+	assert.Error(t, err)
+	assert.Nil(t, plan)
+
+	expr = `JSON_CONTAINS_ALL(A, B)`
+	plan, err = CreateSearchPlan(schema, expr, "FloatVectorField", &planpb.QueryInfo{
+		Topk:         0,
+		MetricType:   "",
+		SearchParams: "",
+		RoundDecimal: 0,
+	})
+	assert.Error(t, err)
+	assert.Nil(t, plan)
+}
+
+func Test_JSONContainsAny(t *testing.T) {
+	schema := newTestSchema()
+	expr := ""
+	var err error
+	var plan *planpb.PlanNode
+
+	expr = `json_contains_any(A, [1,2,3])`
+	plan, err = CreateSearchPlan(schema, expr, "FloatVectorField", &planpb.QueryInfo{
+		Topk:         0,
+		MetricType:   "",
+		SearchParams: "",
+		RoundDecimal: 0,
+	})
+	assert.NoError(t, err)
+	assert.NotNil(t, plan.GetVectorAnns().GetPredicates().GetJsonContainsExpr())
+	assert.Equal(t, planpb.JSONContainsExpr_ContainsAny, plan.GetVectorAnns().GetPredicates().GetJsonContainsExpr().GetOp())
+	assert.True(t, plan.GetVectorAnns().GetPredicates().GetJsonContainsExpr().GetElementsSameType())
+
+	expr = `json_contains_any(A, [1,"2",3.0])`
+	plan, err = CreateSearchPlan(schema, expr, "FloatVectorField", &planpb.QueryInfo{
+		Topk:         0,
+		MetricType:   "",
+		SearchParams: "",
+		RoundDecimal: 0,
+	})
+	assert.NoError(t, err)
+	assert.NotNil(t, plan.GetVectorAnns().GetPredicates().GetJsonContainsExpr())
+	assert.Equal(t, planpb.JSONContainsExpr_ContainsAny, plan.GetVectorAnns().GetPredicates().GetJsonContainsExpr().GetOp())
+	assert.False(t, plan.GetVectorAnns().GetPredicates().GetJsonContainsExpr().GetElementsSameType())
+
+	expr = `JSON_CONTAINS_ANY(A, [1,"2",3.0])`
+	plan, err = CreateSearchPlan(schema, expr, "FloatVectorField", &planpb.QueryInfo{
+		Topk:         0,
+		MetricType:   "",
+		SearchParams: "",
+		RoundDecimal: 0,
+	})
+	assert.NoError(t, err)
+	assert.NotNil(t, plan.GetVectorAnns().GetPredicates().GetJsonContainsExpr())
+	assert.Equal(t, planpb.JSONContainsExpr_ContainsAny, plan.GetVectorAnns().GetPredicates().GetJsonContainsExpr().GetOp())
+	assert.False(t, plan.GetVectorAnns().GetPredicates().GetJsonContainsExpr().GetElementsSameType())
+
+	expr = `JSON_CONTAINS_ANY(A, 1)`
+	plan, err = CreateSearchPlan(schema, expr, "FloatVectorField", &planpb.QueryInfo{
+		Topk:         0,
+		MetricType:   "",
+		SearchParams: "",
+		RoundDecimal: 0,
+	})
+	assert.Error(t, err)
+}
+
+func Test_InvalidJSONContainsAny(t *testing.T) {
+	schema := newTestSchema()
+	expr := ""
+	var err error
+	var plan *planpb.PlanNode
+
+	expr = `JSON_CONTAINS_ANY(A, 1)`
+	plan, err = CreateSearchPlan(schema, expr, "FloatVectorField", &planpb.QueryInfo{
+		Topk:         0,
+		MetricType:   "",
+		SearchParams: "",
+		RoundDecimal: 0,
+	})
+	assert.Error(t, err)
+	assert.Nil(t, plan)
+
+	expr = `JSON_CONTAINS_ANY(A, [abc])`
+	plan, err = CreateSearchPlan(schema, expr, "FloatVectorField", &planpb.QueryInfo{
+		Topk:         0,
+		MetricType:   "",
+		SearchParams: "",
+		RoundDecimal: 0,
+	})
+	assert.Error(t, err)
+	assert.Nil(t, plan)
+
+	expr = `JSON_CONTAINS_ANY(A, [2>a])`
+	plan, err = CreateSearchPlan(schema, expr, "FloatVectorField", &planpb.QueryInfo{
+		Topk:         0,
+		MetricType:   "",
+		SearchParams: "",
+		RoundDecimal: 0,
+	})
+	assert.Error(t, err)
+	assert.Nil(t, plan)
+
+	expr = `JSON_CONTAINS_ANY(A, [2>>a])`
+	plan, err = CreateSearchPlan(schema, expr, "FloatVectorField", &planpb.QueryInfo{
+		Topk:         0,
+		MetricType:   "",
+		SearchParams: "",
+		RoundDecimal: 0,
+	})
+	assert.Error(t, err)
+	assert.Nil(t, plan)
+
+	expr = `JSON_CONTAINS_ANY(A[""], [1,2,3])`
+	plan, err = CreateSearchPlan(schema, expr, "FloatVectorField", &planpb.QueryInfo{
+		Topk:         0,
+		MetricType:   "",
+		SearchParams: "",
+		RoundDecimal: 0,
+	})
+	assert.Error(t, err)
+	assert.Nil(t, plan)
+
+	expr = `JSON_CONTAINS_ANY(Int64Field, [1,2,3])`
+	plan, err = CreateSearchPlan(schema, expr, "FloatVectorField", &planpb.QueryInfo{
+		Topk:         0,
+		MetricType:   "",
+		SearchParams: "",
+		RoundDecimal: 0,
+	})
+	assert.Error(t, err)
+	assert.Nil(t, plan)
+
+	expr = `JSON_CONTAINS_ANY(A, B)`
+	plan, err = CreateSearchPlan(schema, expr, "FloatVectorField", &planpb.QueryInfo{
+		Topk:         0,
+		MetricType:   "",
+		SearchParams: "",
+		RoundDecimal: 0,
+	})
+	assert.Error(t, err)
+	assert.Nil(t, plan)
+}

internal/proto/plan.proto

@@ -35,9 +35,15 @@ message GenericValue {
     int64 int64_val = 2;
     double float_val = 3;
     string string_val = 4;
+    Array array_val = 5;
   };
 }
 
+message Array {
+  repeated GenericValue array = 1;
+  bool same_type = 2;
+}
+
 message QueryInfo {
   int64 topk = 1;
   string metric_type = 3;
@@ -92,6 +98,23 @@ message TermExpr {
   bool is_in_field = 3;
 }
 
+message JSONContainsExpr {
+  ColumnInfo column_info = 1;
+  repeated GenericValue elements = 2;
+  // 0: invalid
+  // 1: json_contains
+  // 2: json_contains_all
+  // 3: json_contains_any
+  enum JSONOp {
+    Invalid = 0;
+    Contains = 1;
+    ContainsAll = 2;
+    ContainsAny = 3;
+  }
+  JSONOp op = 3;
+  bool elements_same_type = 4;
+}
+
 message UnaryExpr {
   enum UnaryOp {
     Invalid = 0;
@@ -148,6 +171,7 @@ message Expr {
     ColumnExpr column_expr = 10;
     ExistsExpr exists_expr = 11;
     AlwaysTrueExpr always_true_expr = 12;
+    JSONContainsExpr json_contains_expr = 13;
   };
 }
 

internal/proto/planpb/plan.pb.go

@@ -116,6 +116,41 @@ func (ArithOpType) EnumDescriptor() ([]byte, []int) {
 	return fileDescriptor_2d655ab2f7683c23, []int{1}
 }
 
+// 0: invalid
+// 1: json_contains
+// 2: json_contains_all
+// 3: json_contains_any
+type JSONContainsExpr_JSONOp int32
+
+const (
+	JSONContainsExpr_Invalid     JSONContainsExpr_JSONOp = 0
+	JSONContainsExpr_Contains    JSONContainsExpr_JSONOp = 1
+	JSONContainsExpr_ContainsAll JSONContainsExpr_JSONOp = 2
+	JSONContainsExpr_ContainsAny JSONContainsExpr_JSONOp = 3
+)
+
+var JSONContainsExpr_JSONOp_name = map[int32]string{
+	0: "Invalid",
+	1: "Contains",
+	2: "ContainsAll",
+	3: "ContainsAny",
+}
+
+var JSONContainsExpr_JSONOp_value = map[string]int32{
+	"Invalid":     0,
+	"Contains":    1,
+	"ContainsAll": 2,
+	"ContainsAny": 3,
+}
+
+func (x JSONContainsExpr_JSONOp) String() string {
+	return proto.EnumName(JSONContainsExpr_JSONOp_name, int32(x))
+}
+
+func (JSONContainsExpr_JSONOp) EnumDescriptor() ([]byte, []int) {
+	return fileDescriptor_2d655ab2f7683c23, []int{11, 0}
+}
+
 type UnaryExpr_UnaryOp int32
 
 const (
@@ -138,7 +173,7 @@ func (x UnaryExpr_UnaryOp) String() string {
 }
 
 func (UnaryExpr_UnaryOp) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_2d655ab2f7683c23, []int{10, 0}
+	return fileDescriptor_2d655ab2f7683c23, []int{12, 0}
 }
 
 type BinaryExpr_BinaryOp int32
@@ -166,7 +201,7 @@ func (x BinaryExpr_BinaryOp) String() string {
 }
 
 func (BinaryExpr_BinaryOp) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_2d655ab2f7683c23, []int{11, 0}
+	return fileDescriptor_2d655ab2f7683c23, []int{13, 0}
 }
 
 type GenericValue struct {
@@ -175,6 +210,7 @@ type GenericValue struct {
 	//	*GenericValue_Int64Val
 	//	*GenericValue_FloatVal
 	//	*GenericValue_StringVal
+	//	*GenericValue_ArrayVal
 	Val                  isGenericValue_Val `protobuf_oneof:"val"`
 	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
 	XXX_unrecognized     []byte             `json:"-"`
@@ -226,6 +262,10 @@ type GenericValue_StringVal struct {
 	StringVal string `protobuf:"bytes,4,opt,name=string_val,json=stringVal,proto3,oneof"`
 }
 
+type GenericValue_ArrayVal struct {
+	ArrayVal *Array `protobuf:"bytes,5,opt,name=array_val,json=arrayVal,proto3,oneof"`
+}
+
 func (*GenericValue_BoolVal) isGenericValue_Val() {}
 
 func (*GenericValue_Int64Val) isGenericValue_Val() {}
@@ -234,6 +274,8 @@ func (*GenericValue_FloatVal) isGenericValue_Val() {}
 
 func (*GenericValue_StringVal) isGenericValue_Val() {}
 
+func (*GenericValue_ArrayVal) isGenericValue_Val() {}
+
 func (m *GenericValue) GetVal() isGenericValue_Val {
 	if m != nil {
 		return m.Val
@@ -269,6 +311,13 @@ func (m *GenericValue) GetStringVal() string {
 	return ""
 }
 
+func (m *GenericValue) GetArrayVal() *Array {
+	if x, ok := m.GetVal().(*GenericValue_ArrayVal); ok {
+		return x.ArrayVal
+	}
+	return nil
+}
+
 // XXX_OneofWrappers is for the internal use of the proto package.
 func (*GenericValue) XXX_OneofWrappers() []interface{} {
 	return []interface{}{
@@ -276,9 +325,57 @@ func (*GenericValue) XXX_OneofWrappers() []interface{} {
 		(*GenericValue_Int64Val)(nil),
 		(*GenericValue_FloatVal)(nil),
 		(*GenericValue_StringVal)(nil),
+		(*GenericValue_ArrayVal)(nil),
 	}
 }
 
+type Array struct {
+	Array                []*GenericValue `protobuf:"bytes,1,rep,name=array,proto3" json:"array,omitempty"`
+	SameType             bool            `protobuf:"varint,2,opt,name=same_type,json=sameType,proto3" json:"same_type,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
+	XXX_unrecognized     []byte          `json:"-"`
+	XXX_sizecache        int32           `json:"-"`
+}
+
+func (m *Array) Reset()         { *m = Array{} }
+func (m *Array) String() string { return proto.CompactTextString(m) }
+func (*Array) ProtoMessage()    {}
+func (*Array) Descriptor() ([]byte, []int) {
+	return fileDescriptor_2d655ab2f7683c23, []int{1}
+}
+
+func (m *Array) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_Array.Unmarshal(m, b)
+}
+func (m *Array) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_Array.Marshal(b, m, deterministic)
+}
+func (m *Array) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Array.Merge(m, src)
+}
+func (m *Array) XXX_Size() int {
+	return xxx_messageInfo_Array.Size(m)
+}
+func (m *Array) XXX_DiscardUnknown() {
+	xxx_messageInfo_Array.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Array proto.InternalMessageInfo
+
+func (m *Array) GetArray() []*GenericValue {
+	if m != nil {
+		return m.Array
+	}
+	return nil
+}
+
+func (m *Array) GetSameType() bool {
+	if m != nil {
+		return m.SameType
+	}
+	return false
+}
+
 type QueryInfo struct {
 	Topk                 int64    `protobuf:"varint,1,opt,name=topk,proto3" json:"topk,omitempty"`
 	MetricType           string   `protobuf:"bytes,3,opt,name=metric_type,json=metricType,proto3" json:"metric_type,omitempty"`
@@ -293,7 +390,7 @@ func (m *QueryInfo) Reset()         { *m = QueryInfo{} }
 func (m *QueryInfo) String() string { return proto.CompactTextString(m) }
 func (*QueryInfo) ProtoMessage()    {}
 func (*QueryInfo) Descriptor() ([]byte, []int) {
-	return fileDescriptor_2d655ab2f7683c23, []int{1}
+	return fileDescriptor_2d655ab2f7683c23, []int{2}
 }
 
 func (m *QueryInfo) XXX_Unmarshal(b []byte) error {
@@ -358,7 +455,7 @@ func (m *ColumnInfo) Reset()         { *m = ColumnInfo{} }
 func (m *ColumnInfo) String() string { return proto.CompactTextString(m) }
 func (*ColumnInfo) ProtoMessage()    {}
 func (*ColumnInfo) Descriptor() ([]byte, []int) {
-	return fileDescriptor_2d655ab2f7683c23, []int{2}
+	return fileDescriptor_2d655ab2f7683c23, []int{3}
 }
 
 func (m *ColumnInfo) XXX_Unmarshal(b []byte) error {
@@ -432,7 +529,7 @@ func (m *ColumnExpr) Reset()         { *m = ColumnExpr{} }
 func (m *ColumnExpr) String() string { return proto.CompactTextString(m) }
 func (*ColumnExpr) ProtoMessage()    {}
 func (*ColumnExpr) Descriptor() ([]byte, []int) {
-	return fileDescriptor_2d655ab2f7683c23, []int{3}
+	return fileDescriptor_2d655ab2f7683c23, []int{4}
 }
 
 func (m *ColumnExpr) XXX_Unmarshal(b []byte) error {
@@ -471,7 +568,7 @@ func (m *ExistsExpr) Reset()         { *m = ExistsExpr{} }
 func (m *ExistsExpr) String() string { return proto.CompactTextString(m) }
 func (*ExistsExpr) ProtoMessage()    {}
 func (*ExistsExpr) Descriptor() ([]byte, []int) {
-	return fileDescriptor_2d655ab2f7683c23, []int{4}
+	return fileDescriptor_2d655ab2f7683c23, []int{5}
 }
 
 func (m *ExistsExpr) XXX_Unmarshal(b []byte) error {
@@ -510,7 +607,7 @@ func (m *ValueExpr) Reset()         { *m = ValueExpr{} }
 func (m *ValueExpr) String() string { return proto.CompactTextString(m) }
 func (*ValueExpr) ProtoMessage()    {}
 func (*ValueExpr) Descriptor() ([]byte, []int) {
-	return fileDescriptor_2d655ab2f7683c23, []int{5}
+	return fileDescriptor_2d655ab2f7683c23, []int{6}
 }
 
 func (m *ValueExpr) XXX_Unmarshal(b []byte) error {
@@ -551,7 +648,7 @@ func (m *UnaryRangeExpr) Reset()         { *m = UnaryRangeExpr{} }
 func (m *UnaryRangeExpr) String() string { return proto.CompactTextString(m) }
 func (*UnaryRangeExpr) ProtoMessage()    {}
 func (*UnaryRangeExpr) Descriptor() ([]byte, []int) {
-	return fileDescriptor_2d655ab2f7683c23, []int{6}
+	return fileDescriptor_2d655ab2f7683c23, []int{7}
 }
 
 func (m *UnaryRangeExpr) XXX_Unmarshal(b []byte) error {
@@ -608,7 +705,7 @@ func (m *BinaryRangeExpr) Reset()         { *m = BinaryRangeExpr{} }
 func (m *BinaryRangeExpr) String() string { return proto.CompactTextString(m) }
 func (*BinaryRangeExpr) ProtoMessage()    {}
 func (*BinaryRangeExpr) Descriptor() ([]byte, []int) {
-	return fileDescriptor_2d655ab2f7683c23, []int{7}
+	return fileDescriptor_2d655ab2f7683c23, []int{8}
 }
 
 func (m *BinaryRangeExpr) XXX_Unmarshal(b []byte) error {
@@ -677,7 +774,7 @@ func (m *CompareExpr) Reset()         { *m = CompareExpr{} }
 func (m *CompareExpr) String() string { return proto.CompactTextString(m) }
 func (*CompareExpr) ProtoMessage()    {}
 func (*CompareExpr) Descriptor() ([]byte, []int) {
-	return fileDescriptor_2d655ab2f7683c23, []int{8}
+	return fileDescriptor_2d655ab2f7683c23, []int{9}
 }
 
 func (m *CompareExpr) XXX_Unmarshal(b []byte) error {
@@ -732,7 +829,7 @@ func (m *TermExpr) Reset()         { *m = TermExpr{} }
 func (m *TermExpr) String() string { return proto.CompactTextString(m) }
 func (*TermExpr) ProtoMessage()    {}
 func (*TermExpr) Descriptor() ([]byte, []int) {
-	return fileDescriptor_2d655ab2f7683c23, []int{9}
+	return fileDescriptor_2d655ab2f7683c23, []int{10}
 }
 
 func (m *TermExpr) XXX_Unmarshal(b []byte) error {
@@ -774,6 +871,69 @@ func (m *TermExpr) GetIsInField() bool {
 	return false
 }
 
+type JSONContainsExpr struct {
+	ColumnInfo           *ColumnInfo             `protobuf:"bytes,1,opt,name=column_info,json=columnInfo,proto3" json:"column_info,omitempty"`
+	Elements             []*GenericValue         `protobuf:"bytes,2,rep,name=elements,proto3" json:"elements,omitempty"`
+	Op                   JSONContainsExpr_JSONOp `protobuf:"varint,3,opt,name=op,proto3,enum=milvus.proto.plan.JSONContainsExpr_JSONOp" json:"op,omitempty"`
+	ElementsSameType     bool                    `protobuf:"varint,4,opt,name=elements_same_type,json=elementsSameType,proto3" json:"elements_same_type,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}                `json:"-"`
+	XXX_unrecognized     []byte                  `json:"-"`
+	XXX_sizecache        int32                   `json:"-"`
+}
+
+func (m *JSONContainsExpr) Reset()         { *m = JSONContainsExpr{} }
+func (m *JSONContainsExpr) String() string { return proto.CompactTextString(m) }
+func (*JSONContainsExpr) ProtoMessage()    {}
+func (*JSONContainsExpr) Descriptor() ([]byte, []int) {
+	return fileDescriptor_2d655ab2f7683c23, []int{11}
+}
+
+func (m *JSONContainsExpr) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_JSONContainsExpr.Unmarshal(m, b)
+}
+func (m *JSONContainsExpr) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_JSONContainsExpr.Marshal(b, m, deterministic)
+}
+func (m *JSONContainsExpr) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_JSONContainsExpr.Merge(m, src)
+}
+func (m *JSONContainsExpr) XXX_Size() int {
+	return xxx_messageInfo_JSONContainsExpr.Size(m)
+}
+func (m *JSONContainsExpr) XXX_DiscardUnknown() {
+	xxx_messageInfo_JSONContainsExpr.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_JSONContainsExpr proto.InternalMessageInfo
+
+func (m *JSONContainsExpr) GetColumnInfo() *ColumnInfo {
+	if m != nil {
+		return m.ColumnInfo
+	}
+	return nil
+}
+
+func (m *JSONContainsExpr) GetElements() []*GenericValue {
+	if m != nil {
+		return m.Elements
+	}
+	return nil
+}
+
+func (m *JSONContainsExpr) GetOp() JSONContainsExpr_JSONOp {
+	if m != nil {
+		return m.Op
+	}
+	return JSONContainsExpr_Invalid
+}
+
+func (m *JSONContainsExpr) GetElementsSameType() bool {
+	if m != nil {
+		return m.ElementsSameType
+	}
+	return false
+}
+
 type UnaryExpr struct {
 	Op                   UnaryExpr_UnaryOp `protobuf:"varint,1,opt,name=op,proto3,enum=milvus.proto.plan.UnaryExpr_UnaryOp" json:"op,omitempty"`
 	Child                *Expr             `protobuf:"bytes,2,opt,name=child,proto3" json:"child,omitempty"`
@@ -786,7 +946,7 @@ func (m *UnaryExpr) Reset()         { *m = UnaryExpr{} }
 func (m *UnaryExpr) String() string { return proto.CompactTextString(m) }
 func (*UnaryExpr) ProtoMessage()    {}
 func (*UnaryExpr) Descriptor() ([]byte, []int) {
-	return fileDescriptor_2d655ab2f7683c23, []int{10}
+	return fileDescriptor_2d655ab2f7683c23, []int{12}
 }
 
 func (m *UnaryExpr) XXX_Unmarshal(b []byte) error {
@@ -834,7 +994,7 @@ func (m *BinaryExpr) Reset()         { *m = BinaryExpr{} }
 func (m *BinaryExpr) String() string { return proto.CompactTextString(m) }
 func (*BinaryExpr) ProtoMessage()    {}
 func (*BinaryExpr) Descriptor() ([]byte, []int) {
-	return fileDescriptor_2d655ab2f7683c23, []int{11}
+	return fileDescriptor_2d655ab2f7683c23, []int{13}
 }
 
 func (m *BinaryExpr) XXX_Unmarshal(b []byte) error {
@@ -889,7 +1049,7 @@ func (m *BinaryArithOp) Reset()         { *m = BinaryArithOp{} }
 func (m *BinaryArithOp) String() string { return proto.CompactTextString(m) }
 func (*BinaryArithOp) ProtoMessage()    {}
 func (*BinaryArithOp) Descriptor() ([]byte, []int) {
-	return fileDescriptor_2d655ab2f7683c23, []int{12}
+	return fileDescriptor_2d655ab2f7683c23, []int{14}
 }
 
 func (m *BinaryArithOp) XXX_Unmarshal(b []byte) error {
@@ -944,7 +1104,7 @@ func (m *BinaryArithExpr) Reset()         { *m = BinaryArithExpr{} }
 func (m *BinaryArithExpr) String() string { return proto.CompactTextString(m) }
 func (*BinaryArithExpr) ProtoMessage()    {}
 func (*BinaryArithExpr) Descriptor() ([]byte, []int) {
-	return fileDescriptor_2d655ab2f7683c23, []int{13}
+	return fileDescriptor_2d655ab2f7683c23, []int{15}
 }
 
 func (m *BinaryArithExpr) XXX_Unmarshal(b []byte) error {
@@ -1001,7 +1161,7 @@ func (m *BinaryArithOpEvalRangeExpr) Reset()         { *m = BinaryArithOpEvalRan
 func (m *BinaryArithOpEvalRangeExpr) String() string { return proto.CompactTextString(m) }
 func (*BinaryArithOpEvalRangeExpr) ProtoMessage()    {}
 func (*BinaryArithOpEvalRangeExpr) Descriptor() ([]byte, []int) {
-	return fileDescriptor_2d655ab2f7683c23, []int{14}
+	return fileDescriptor_2d655ab2f7683c23, []int{16}
 }
 
 func (m *BinaryArithOpEvalRangeExpr) XXX_Unmarshal(b []byte) error {
@@ -1067,7 +1227,7 @@ func (m *AlwaysTrueExpr) Reset()         { *m = AlwaysTrueExpr{} }
 func (m *AlwaysTrueExpr) String() string { return proto.CompactTextString(m) }
 func (*AlwaysTrueExpr) ProtoMessage()    {}
 func (*AlwaysTrueExpr) Descriptor() ([]byte, []int) {
-	return fileDescriptor_2d655ab2f7683c23, []int{15}
+	return fileDescriptor_2d655ab2f7683c23, []int{17}
 }
 
 func (m *AlwaysTrueExpr) XXX_Unmarshal(b []byte) error {
@@ -1102,6 +1262,7 @@ type Expr struct {
 	//	*Expr_ColumnExpr
 	//	*Expr_ExistsExpr
 	//	*Expr_AlwaysTrueExpr
+	//	*Expr_JsonContainsExpr
 	Expr                 isExpr_Expr `protobuf_oneof:"expr"`
 	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
 	XXX_unrecognized     []byte      `json:"-"`
@@ -1112,7 +1273,7 @@ func (m *Expr) Reset()         { *m = Expr{} }
 func (m *Expr) String() string { return proto.CompactTextString(m) }
 func (*Expr) ProtoMessage()    {}
 func (*Expr) Descriptor() ([]byte, []int) {
-	return fileDescriptor_2d655ab2f7683c23, []int{16}
+	return fileDescriptor_2d655ab2f7683c23, []int{18}
 }
 
 func (m *Expr) XXX_Unmarshal(b []byte) error {
@@ -1185,6 +1346,10 @@ type Expr_AlwaysTrueExpr struct {
 	AlwaysTrueExpr *AlwaysTrueExpr `protobuf:"bytes,12,opt,name=always_true_expr,json=alwaysTrueExpr,proto3,oneof"`
 }
 
+type Expr_JsonContainsExpr struct {
+	JsonContainsExpr *JSONContainsExpr `protobuf:"bytes,13,opt,name=json_contains_expr,json=jsonContainsExpr,proto3,oneof"`
+}
+
 func (*Expr_TermExpr) isExpr_Expr() {}
 
 func (*Expr_UnaryExpr) isExpr_Expr() {}
@@ -1209,6 +1374,8 @@ func (*Expr_ExistsExpr) isExpr_Expr() {}
 
 func (*Expr_AlwaysTrueExpr) isExpr_Expr() {}
 
+func (*Expr_JsonContainsExpr) isExpr_Expr() {}
+
 func (m *Expr) GetExpr() isExpr_Expr {
 	if m != nil {
 		return m.Expr
@@ -1300,6 +1467,13 @@ func (m *Expr) GetAlwaysTrueExpr() *AlwaysTrueExpr {
 	return nil
 }
 
+func (m *Expr) GetJsonContainsExpr() *JSONContainsExpr {
+	if x, ok := m.GetExpr().(*Expr_JsonContainsExpr); ok {
+		return x.JsonContainsExpr
+	}
+	return nil
+}
+
 // XXX_OneofWrappers is for the internal use of the proto package.
 func (*Expr) XXX_OneofWrappers() []interface{} {
 	return []interface{}{
@@ -1315,6 +1489,7 @@ func (*Expr) XXX_OneofWrappers() []interface{} {
 		(*Expr_ColumnExpr)(nil),
 		(*Expr_ExistsExpr)(nil),
 		(*Expr_AlwaysTrueExpr)(nil),
+		(*Expr_JsonContainsExpr)(nil),
 	}
 }
 
@@ -1333,7 +1508,7 @@ func (m *VectorANNS) Reset()         { *m = VectorANNS{} }
 func (m *VectorANNS) String() string { return proto.CompactTextString(m) }
 func (*VectorANNS) ProtoMessage()    {}
 func (*VectorANNS) Descriptor() ([]byte, []int) {
-	return fileDescriptor_2d655ab2f7683c23, []int{17}
+	return fileDescriptor_2d655ab2f7683c23, []int{19}
 }
 
 func (m *VectorANNS) XXX_Unmarshal(b []byte) error {
@@ -1402,7 +1577,7 @@ func (m *QueryPlanNode) Reset()         { *m = QueryPlanNode{} }
 func (m *QueryPlanNode) String() string { return proto.CompactTextString(m) }
 func (*QueryPlanNode) ProtoMessage()    {}
 func (*QueryPlanNode) Descriptor() ([]byte, []int) {
-	return fileDescriptor_2d655ab2f7683c23, []int{18}
+	return fileDescriptor_2d655ab2f7683c23, []int{20}
 }
 
 func (m *QueryPlanNode) XXX_Unmarshal(b []byte) error {
@@ -1460,7 +1635,7 @@ func (m *PlanNode) Reset()         { *m = PlanNode{} }
 func (m *PlanNode) String() string { return proto.CompactTextString(m) }
 func (*PlanNode) ProtoMessage()    {}
 func (*PlanNode) Descriptor() ([]byte, []int) {
-	return fileDescriptor_2d655ab2f7683c23, []int{19}
+	return fileDescriptor_2d655ab2f7683c23, []int{21}
 }
 
 func (m *PlanNode) XXX_Unmarshal(b []byte) error {
@@ -1550,9 +1725,11 @@ func (*PlanNode) XXX_OneofWrappers() []interface{} {
 func init() {
 	proto.RegisterEnum("milvus.proto.plan.OpType", OpType_name, OpType_value)
 	proto.RegisterEnum("milvus.proto.plan.ArithOpType", ArithOpType_name, ArithOpType_value)
+	proto.RegisterEnum("milvus.proto.plan.JSONContainsExpr_JSONOp", JSONContainsExpr_JSONOp_name, JSONContainsExpr_JSONOp_value)
 	proto.RegisterEnum("milvus.proto.plan.UnaryExpr_UnaryOp", UnaryExpr_UnaryOp_name, UnaryExpr_UnaryOp_value)
 	proto.RegisterEnum("milvus.proto.plan.BinaryExpr_BinaryOp", BinaryExpr_BinaryOp_name, BinaryExpr_BinaryOp_value)
 	proto.RegisterType((*GenericValue)(nil), "milvus.proto.plan.GenericValue")
+	proto.RegisterType((*Array)(nil), "milvus.proto.plan.Array")
 	proto.RegisterType((*QueryInfo)(nil), "milvus.proto.plan.QueryInfo")
 	proto.RegisterType((*ColumnInfo)(nil), "milvus.proto.plan.ColumnInfo")
 	proto.RegisterType((*ColumnExpr)(nil), "milvus.proto.plan.ColumnExpr")
@@ -1562,6 +1739,7 @@ func init() {
 	proto.RegisterType((*BinaryRangeExpr)(nil), "milvus.proto.plan.BinaryRangeExpr")
 	proto.RegisterType((*CompareExpr)(nil), "milvus.proto.plan.CompareExpr")
 	proto.RegisterType((*TermExpr)(nil), "milvus.proto.plan.TermExpr")
+	proto.RegisterType((*JSONContainsExpr)(nil), "milvus.proto.plan.JSONContainsExpr")
 	proto.RegisterType((*UnaryExpr)(nil), "milvus.proto.plan.UnaryExpr")
 	proto.RegisterType((*BinaryExpr)(nil), "milvus.proto.plan.BinaryExpr")
 	proto.RegisterType((*BinaryArithOp)(nil), "milvus.proto.plan.BinaryArithOp")
@@ -1577,105 +1755,116 @@ func init() {
 func init() { proto.RegisterFile("plan.proto", fileDescriptor_2d655ab2f7683c23) }
 
 var fileDescriptor_2d655ab2f7683c23 = []byte{
-	// 1591 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x57, 0x4f, 0x93, 0xe3, 0x46,
-	0x15, 0xb7, 0x2c, 0x7b, 0x2c, 0x3d, 0x79, 0x3c, 0x5a, 0x15, 0x55, 0xec, 0x1f, 0xb2, 0x33, 0x88,
-	0x14, 0x19, 0x42, 0xed, 0x6c, 0x85, 0x84, 0x0d, 0x09, 0x15, 0x98, 0x7f, 0x9b, 0xb5, 0x2b, 0xd9,
-	0x19, 0xa3, 0x4c, 0xf6, 0xc0, 0x45, 0xd5, 0x96, 0x7a, 0xc6, 0x5d, 0x2b, 0x77, 0x6b, 0x5b, 0x2d,
-	0xef, 0xfa, 0x2b, 0xc0, 0x89, 0x0f, 0xc0, 0x89, 0x03, 0x77, 0x8e, 0x5c, 0xf8, 0x02, 0x1c, 0x38,
-	0x72, 0xe7, 0x13, 0x50, 0x7c, 0x01, 0xaa, 0x5f, 0xcb, 0xff, 0xa6, 0xec, 0x1d, 0x0f, 0x6c, 0x55,
-	0x6e, 0xdd, 0xaf, 0xfb, 0xfd, 0xde, 0xff, 0xd7, 0xaf, 0x01, 0xf2, 0x8c, 0xf0, 0x83, 0x5c, 0x0a,
-	0x25, 0x82, 0x3b, 0x23, 0x96, 0x8d, 0xcb, 0xc2, 0xec, 0x0e, 0xf4, 0xc1, 0xfd, 0x76, 0x91, 0x0c,
-	0xe9, 0x88, 0x18, 0x52, 0xf8, 0x07, 0x0b, 0xda, 0xcf, 0x28, 0xa7, 0x92, 0x25, 0x2f, 0x48, 0x56,
-	0xd2, 0xe0, 0x01, 0x38, 0x03, 0x21, 0xb2, 0x78, 0x4c, 0xb2, 0xbb, 0xd6, 0x9e, 0xb5, 0xef, 0x74,
-	0x6b, 0x51, 0x4b, 0x53, 0x5e, 0x90, 0x2c, 0x78, 0x0f, 0x5c, 0xc6, 0xd5, 0x93, 0x4f, 0xf0, 0xb4,
-	0xbe, 0x67, 0xed, 0xdb, 0xdd, 0x5a, 0xe4, 0x20, 0xa9, 0x3a, 0xbe, 0xcc, 0x04, 0x51, 0x78, 0x6c,
-	0xef, 0x59, 0xfb, 0x96, 0x3e, 0x46, 0x92, 0x3e, 0xde, 0x05, 0x28, 0x94, 0x64, 0xfc, 0x0a, 0xcf,
-	0x1b, 0x7b, 0xd6, 0xbe, 0xdb, 0xad, 0x45, 0xae, 0xa1, 0xbd, 0x20, 0xd9, 0x71, 0x13, 0xec, 0x31,
-	0xc9, 0xc2, 0xdf, 0x59, 0xe0, 0xfe, 0xa6, 0xa4, 0x72, 0xd2, 0xe3, 0x97, 0x22, 0x08, 0xa0, 0xa1,
-	0x44, 0xfe, 0x12, 0x95, 0xb1, 0x23, 0x5c, 0x07, 0xbb, 0xe0, 0x8d, 0xa8, 0x92, 0x2c, 0x89, 0xd5,
-	0x24, 0xa7, 0x28, 0xca, 0x8d, 0xc0, 0x90, 0x2e, 0x26, 0x39, 0x0d, 0x7e, 0x04, 0xdb, 0x05, 0x25,
-	0x32, 0x19, 0xc6, 0x39, 0x91, 0x64, 0x54, 0x18, 0x69, 0x51, 0xdb, 0x10, 0xfb, 0x48, 0xd3, 0x97,
-	0xa4, 0x28, 0x79, 0x1a, 0xa7, 0x34, 0x61, 0x23, 0x92, 0xdd, 0x6d, 0xa2, 0x88, 0x36, 0x12, 0x4f,
-	0x0d, 0x2d, 0xfc, 0xb7, 0x05, 0x70, 0x22, 0xb2, 0x72, 0xc4, 0x51, 0x9b, 0x7b, 0xe0, 0x5c, 0x32,
-	0x9a, 0xa5, 0x31, 0x4b, 0x2b, 0x8d, 0x5a, 0xb8, 0xef, 0xa5, 0xc1, 0xe7, 0xe0, 0xa6, 0x44, 0x11,
-	0xa3, 0x92, 0x76, 0x4e, 0xe7, 0x67, 0xef, 0x1d, 0x2c, 0xf9, 0xbf, 0xf2, 0xfc, 0x29, 0x51, 0x44,
-	0x6b, 0x19, 0x39, 0x69, 0xb5, 0x0a, 0xde, 0x87, 0x0e, 0x2b, 0xe2, 0x5c, 0xb2, 0x11, 0x91, 0x93,
-	0xf8, 0x25, 0x9d, 0xa0, 0x4d, 0x4e, 0xd4, 0x66, 0x45, 0xdf, 0x10, 0xbf, 0xa2, 0x93, 0xe0, 0x01,
-	0xb8, 0xac, 0x88, 0x49, 0xa9, 0x44, 0xef, 0x14, 0x2d, 0x72, 0x22, 0x87, 0x15, 0x47, 0xb8, 0xd7,
-	0x3e, 0xe1, 0xb4, 0x50, 0x34, 0x8d, 0x73, 0xa2, 0x86, 0x77, 0x9b, 0x7b, 0xb6, 0xf6, 0x89, 0x21,
-	0xf5, 0x89, 0x1a, 0x06, 0xfb, 0xe0, 0x6b, 0x19, 0x44, 0x2a, 0xa6, 0x98, 0xe0, 0x28, 0x65, 0x0b,
-	0x41, 0x3a, 0xac, 0xe8, 0x4f, 0xc9, 0x5f, 0xd1, 0x49, 0xf8, 0xeb, 0xa9, 0xc9, 0x4f, 0xdf, 0xe4,
-	0x32, 0xf8, 0x08, 0x1a, 0x8c, 0x5f, 0x0a, 0x34, 0xd7, 0xbb, 0x6e, 0x12, 0xe6, 0xda, 0xdc, 0x3f,
-	0x11, 0x5e, 0xd5, 0x00, 0x4f, 0xdf, 0xb0, 0x42, 0x15, 0xff, 0x2b, 0xc0, 0x31, 0xb8, 0x98, 0x8e,
-	0xc8, 0xff, 0x73, 0x68, 0x8e, 0xf5, 0xa6, 0x02, 0xd8, 0x5d, 0x01, 0xb0, 0x98, 0xc2, 0x91, 0xb9,
-	0x1d, 0xfe, 0xc5, 0x82, 0xce, 0xb7, 0x9c, 0xc8, 0x49, 0x44, 0xf8, 0x95, 0x41, 0xfa, 0x15, 0x78,
-	0x09, 0x8a, 0x8a, 0x37, 0x57, 0x08, 0x92, 0x79, 0xf4, 0x7f, 0x02, 0x75, 0x91, 0x57, 0xb1, 0xbd,
-	0xb7, 0x82, 0xed, 0x3c, 0xc7, 0xb8, 0xd6, 0x45, 0x3e, 0x57, 0xda, 0xbe, 0x95, 0xd2, 0x7f, 0xae,
-	0xc3, 0xce, 0x31, 0x7b, 0xb7, 0x5a, 0x7f, 0x00, 0x3b, 0x99, 0x78, 0x4d, 0x65, 0xcc, 0x78, 0x92,
-	0x95, 0x05, 0x1b, 0x9b, 0xf4, 0x74, 0xa2, 0x0e, 0x92, 0x7b, 0x53, 0xaa, 0xbe, 0x58, 0xe6, 0xf9,
-	0xd2, 0x45, 0x93, 0x86, 0x1d, 0x24, 0xcf, 0x2f, 0x1e, 0x82, 0x67, 0x10, 0x8d, 0x89, 0x8d, 0xcd,
-	0x4c, 0x04, 0xe4, 0x31, 0x6d, 0xe6, 0x10, 0x3c, 0x23, 0xca, 0x20, 0x34, 0x37, 0x44, 0x40, 0x1e,
-	0x5c, 0x87, 0x7f, 0xb7, 0xc0, 0x3b, 0x11, 0xa3, 0x9c, 0x48, 0xe3, 0xa5, 0x67, 0xe0, 0x67, 0xf4,
-	0x52, 0xc5, 0xb7, 0x76, 0x55, 0x47, 0xb3, 0x2d, 0x94, 0x78, 0x0f, 0xee, 0x48, 0x76, 0x35, 0x5c,
-	0x46, 0xaa, 0x6f, 0x82, 0xb4, 0x83, 0x7c, 0x27, 0xd7, 0xf3, 0xc5, 0xde, 0x20, 0x5f, 0xc2, 0x3f,
-	0x59, 0xe0, 0x5c, 0x50, 0x39, 0x7a, 0x27, 0x11, 0xff, 0x14, 0xb6, 0xd0, 0xaf, 0xc5, 0xdd, 0xfa,
-	0x9e, 0xbd, 0x89, 0x63, 0xab, 0xeb, 0xc1, 0x43, 0xf0, 0x58, 0x11, 0x33, 0x1e, 0x63, 0x53, 0xab,
-	0xa2, 0xef, 0xb2, 0xa2, 0xc7, 0xbf, 0xd4, 0x04, 0xfd, 0x5c, 0xb8, 0x58, 0x53, 0xa8, 0xe6, 0x27,
-	0x68, 0x9e, 0x85, 0xe6, 0xbd, 0xbf, 0x42, 0xc4, 0xec, 0xa6, 0x59, 0x9d, 0xe7, 0x58, 0x19, 0x8f,
-	0xa0, 0x99, 0x0c, 0x59, 0x96, 0x56, 0x3e, 0xfd, 0xfe, 0x0a, 0x46, 0xcd, 0x13, 0x99, 0x5b, 0xe1,
-	0x2e, 0xb4, 0x2a, 0xee, 0xc0, 0x83, 0x56, 0x8f, 0x8f, 0x49, 0xc6, 0x52, 0xbf, 0x16, 0xb4, 0xc0,
-	0x3e, 0x13, 0xca, 0xb7, 0xc2, 0x7f, 0x5a, 0x00, 0xa6, 0x64, 0x50, 0xa9, 0x27, 0x0b, 0x4a, 0xfd,
-	0x78, 0x05, 0xf6, 0xfc, 0x6a, 0xb5, 0xac, 0xd4, 0xfa, 0x29, 0x34, 0x74, 0x22, 0xdc, 0xa4, 0x15,
-	0x5e, 0xd2, 0x36, 0x60, 0xac, 0xab, 0xea, 0x5e, 0x6f, 0x03, 0xde, 0x0a, 0x9f, 0x80, 0x33, 0x95,
-	0xb5, 0x6c, 0x44, 0x07, 0xe0, 0x6b, 0x71, 0xc5, 0x12, 0x92, 0x1d, 0xf1, 0xd4, 0xb7, 0x82, 0x6d,
-	0x70, 0xab, 0xfd, 0xb9, 0xf4, 0xeb, 0xe1, 0x3f, 0x2c, 0xd8, 0x36, 0x8c, 0x47, 0x92, 0xa9, 0xe1,
-	0x79, 0xfe, 0x7f, 0x67, 0xc6, 0x67, 0xe0, 0x10, 0x0d, 0x15, 0xcf, 0xfa, 0xd8, 0xc3, 0x15, 0xcc,
-	0x95, 0x34, 0x4c, 0xce, 0x16, 0xa9, 0x44, 0x9f, 0xc2, 0xb6, 0xa9, 0x0b, 0x91, 0x53, 0x49, 0x78,
-	0xba, 0x69, 0x67, 0x6b, 0x23, 0xd7, 0xb9, 0x61, 0x0a, 0xff, 0x68, 0x4d, 0x1b, 0x1c, 0x0a, 0xc1,
-	0x90, 0x4d, 0x5d, 0x6f, 0xdd, 0xca, 0xf5, 0xf5, 0x4d, 0x5c, 0x1f, 0x1c, 0x2c, 0x94, 0xe0, 0x4d,
-	0xa6, 0xea, 0x3a, 0xfc, 0x5b, 0x1d, 0xee, 0x2f, 0xb9, 0xfc, 0xe9, 0x98, 0x64, 0xef, 0xae, 0x17,
-	0x7f, 0xd7, 0xfe, 0xaf, 0x5a, 0x52, 0xe3, 0x56, 0x4f, 0x58, 0xf3, 0x56, 0x4f, 0x98, 0x0f, 0x9d,
-	0xa3, 0xec, 0x35, 0x99, 0x14, 0x17, 0xd2, 0x3c, 0xe0, 0xe1, 0xef, 0x5b, 0xd0, 0x40, 0xef, 0x7d,
-	0x0e, 0xae, 0xa2, 0x72, 0x14, 0xd3, 0x37, 0xb9, 0xac, 0x7c, 0xf7, 0x60, 0x05, 0xea, 0xb4, 0x0f,
-	0xea, 0xe9, 0x51, 0x4d, 0x7b, 0xe2, 0x17, 0x00, 0xa5, 0x0e, 0x8b, 0x61, 0x36, 0xc1, 0xff, 0xc1,
-	0xdb, 0x9a, 0x8e, 0x9e, 0x2d, 0xcb, 0x59, 0x5b, 0x38, 0x04, 0x6f, 0xc0, 0xe6, 0xfc, 0xf6, 0xda,
-	0xc0, 0xcd, 0xfb, 0x43, 0xb7, 0x16, 0xc1, 0x60, 0xde, 0x58, 0x4e, 0xa0, 0x9d, 0x98, 0xf7, 0xc6,
-	0x40, 0x98, 0x57, 0xef, 0xe1, 0xca, 0xd8, 0xcf, 0x9e, 0xa5, 0x6e, 0x2d, 0xf2, 0x92, 0x85, 0x57,
-	0xea, 0x39, 0xf8, 0xc6, 0x0a, 0xa9, 0x53, 0xca, 0x00, 0x19, 0xf7, 0xfe, 0x70, 0x9d, 0x2d, 0xb3,
-	0xe4, 0xeb, 0xd6, 0xa2, 0x4e, 0xb9, 0x3c, 0x1a, 0xf4, 0xe1, 0x4e, 0x65, 0xd5, 0x02, 0xde, 0x16,
-	0xe2, 0x85, 0x6b, 0x6d, 0x5b, 0x04, 0xdc, 0x19, 0x5c, 0x1b, 0x36, 0x14, 0xec, 0x56, 0x88, 0xd3,
-	0x3c, 0x8d, 0xe9, 0x98, 0x64, 0x8b, 0xf8, 0x2d, 0xc4, 0x7f, 0xb4, 0x16, 0x7f, 0x55, 0xe1, 0x74,
-	0x6b, 0xd1, 0xfd, 0xc1, 0xfa, 0xb2, 0x9a, 0xdb, 0x61, 0xa4, 0xa2, 0x1c, 0xe7, 0x06, 0x3b, 0x66,
-	0x0d, 0x64, 0x6e, 0xc7, 0xbc, 0xa7, 0x7c, 0x01, 0x80, 0xe9, 0x68, 0xa0, 0xdc, 0xb5, 0xe9, 0x32,
-	0x1b, 0x33, 0x75, 0xba, 0x8c, 0x67, 0x33, 0xe7, 0xe1, 0xac, 0xce, 0x91, 0x1f, 0x6e, 0xa8, 0xf3,
-	0x69, 0xba, 0x24, 0xf3, 0xb1, 0xf9, 0x10, 0x3c, 0x8a, 0x33, 0xb0, 0x41, 0xf0, 0xd6, 0x22, 0xcc,
-	0x27, 0x65, 0x8d, 0x40, 0xe7, 0x73, 0xf3, 0x73, 0xf0, 0x09, 0x16, 0x52, 0xac, 0xe4, 0xd4, 0x90,
-	0xf6, 0xda, 0x5c, 0x59, 0xae, 0x39, 0x9d, 0x2b, 0x64, 0x89, 0x72, 0xbc, 0x05, 0x0d, 0x0d, 0x11,
-	0xfe, 0xcb, 0x02, 0x78, 0x41, 0x13, 0x25, 0xe4, 0xd1, 0xd9, 0xd9, 0x37, 0xd5, 0xa7, 0xc2, 0xb8,
-	0xcf, 0xfc, 0xf8, 0xf4, 0xa7, 0xc2, 0x78, 0x78, 0xe9, 0xbb, 0x53, 0x5f, 0xfe, 0xee, 0x7c, 0x0a,
-	0x90, 0x4b, 0x9a, 0xb2, 0x84, 0x28, 0x5a, 0xdc, 0xf4, 0x0e, 0x2e, 0x5c, 0x0d, 0x7e, 0x09, 0xf0,
-	0x4a, 0xff, 0xee, 0x4c, 0x07, 0x6d, 0xac, 0x8d, 0xcc, 0xec, 0x0b, 0x18, 0xb9, 0xaf, 0x66, 0xbf,
-	0xc1, 0x0f, 0x60, 0x27, 0xcf, 0x48, 0x42, 0x87, 0x22, 0x4b, 0xa9, 0x8c, 0x15, 0xb9, 0xc2, 0xf2,
-	0x71, 0xa3, 0xce, 0x02, 0xf9, 0x82, 0x5c, 0x85, 0x13, 0xd8, 0x46, 0x80, 0x7e, 0x46, 0xf8, 0x99,
-	0x48, 0xe9, 0x35, 0x7d, 0xad, 0xcd, 0xf5, 0xbd, 0x07, 0x0e, 0x2b, 0xe2, 0x44, 0x94, 0x5c, 0x55,
-	0x73, 0x73, 0x8b, 0x15, 0x27, 0x7a, 0x1b, 0x7c, 0x0f, 0x9a, 0x19, 0x1b, 0x31, 0x33, 0x06, 0xd8,
-	0x91, 0xd9, 0x84, 0xff, 0xb1, 0xc0, 0x99, 0x89, 0x3d, 0x04, 0x6f, 0x8c, 0xce, 0x8e, 0x09, 0xe7,
-	0xc5, 0x5b, 0x1e, 0x8c, 0x79, 0x48, 0x74, 0x1a, 0x18, 0x9e, 0x23, 0xce, 0x8b, 0xe0, 0xb3, 0x25,
-	0xc5, 0xdf, 0xfe, 0xea, 0x69, 0xd6, 0x05, 0xd5, 0x7f, 0x01, 0x4d, 0x74, 0x5d, 0xe5, 0xe5, 0xbd,
-	0x75, 0x5e, 0x9e, 0x6a, 0xdb, 0xad, 0x45, 0x86, 0x41, 0x7f, 0x16, 0x45, 0xa9, 0xf2, 0x52, 0xc5,
-	0xd3, 0xf8, 0xeb, 0x18, 0xdb, 0xfb, 0x76, 0xd4, 0x31, 0xf4, 0x2f, 0x4d, 0x1a, 0x14, 0x3a, 0xad,
-	0xb8, 0x48, 0xe9, 0x87, 0x7f, 0xb5, 0x60, 0xcb, 0x3c, 0x1e, 0xcb, 0x23, 0xce, 0x0e, 0x78, 0xcf,
-	0x24, 0x25, 0x8a, 0xca, 0x8b, 0x21, 0xe1, 0xbe, 0x15, 0xf8, 0xd0, 0xae, 0x08, 0x4f, 0x5f, 0x95,
-	0x24, 0xf3, 0xeb, 0x41, 0x1b, 0x9c, 0xaf, 0x69, 0x51, 0xe0, 0xb9, 0x8d, 0x33, 0x10, 0x2d, 0x0a,
-	0x73, 0xd8, 0x08, 0x5c, 0x68, 0x9a, 0x65, 0x53, 0xdf, 0x3b, 0x13, 0xca, 0xec, 0xb6, 0x34, 0x70,
-	0x5f, 0xd2, 0x4b, 0xf6, 0xe6, 0x39, 0x51, 0xc9, 0xd0, 0x6f, 0x69, 0xe0, 0xbe, 0x28, 0xd4, 0x8c,
-	0xe2, 0x68, 0x5e, 0xb3, 0x74, 0xf5, 0x12, 0xdb, 0x8d, 0x0f, 0xc1, 0x16, 0xd4, 0x7b, 0xdc, 0xf7,
-	0x34, 0xe9, 0x4c, 0xa8, 0x1e, 0xf7, 0xdb, 0x1f, 0x3e, 0x03, 0x6f, 0xe1, 0xcd, 0xd5, 0x06, 0x7c,
-	0xcb, 0x5f, 0x72, 0xf1, 0x9a, 0x9b, 0x41, 0xf3, 0x28, 0xd5, 0xc3, 0x59, 0x0b, 0xec, 0x6f, 0xca,
-	0x81, 0x5f, 0xd7, 0x8b, 0xe7, 0x65, 0xe6, 0xdb, 0x7a, 0x71, 0xca, 0xc6, 0x7e, 0x03, 0x29, 0x22,
-	0xf5, 0x9b, 0xc7, 0x1f, 0xff, 0xf6, 0xa3, 0x2b, 0xa6, 0x86, 0xe5, 0xe0, 0x20, 0x11, 0xa3, 0xc7,
-	0xc6, 0xdd, 0x8f, 0x98, 0xa8, 0x56, 0x8f, 0x19, 0x57, 0x54, 0x72, 0x92, 0x3d, 0xc6, 0x08, 0x3c,
-	0xd6, 0x11, 0xc8, 0x07, 0x83, 0x2d, 0xdc, 0x7d, 0xfc, 0xdf, 0x00, 0x00, 0x00, 0xff, 0xff, 0xda,
-	0x25, 0x49, 0xed, 0xba, 0x11, 0x00, 0x00,
+	// 1762 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x58, 0x4f, 0x93, 0xdb, 0x48,
+	0x15, 0xb7, 0x2c, 0x7b, 0x2c, 0x3d, 0x79, 0x3c, 0x8a, 0x8a, 0x2a, 0x26, 0x09, 0x9b, 0x19, 0xb4,
+	0x5b, 0xec, 0x10, 0xc8, 0xa4, 0x36, 0xbb, 0x9b, 0xb0, 0xd9, 0x5a, 0x18, 0xcf, 0x9f, 0x8d, 0xcd,
+	0x6e, 0x66, 0x06, 0xcd, 0x6c, 0x0e, 0x70, 0x50, 0xb5, 0xa5, 0x9e, 0x71, 0x13, 0xb9, 0xa5, 0x48,
+	0x2d, 0x27, 0xfe, 0x0a, 0xdc, 0xf8, 0x00, 0x9c, 0x38, 0x70, 0xe7, 0xc8, 0x05, 0xce, 0x14, 0x07,
+	0x8e, 0x1c, 0xa9, 0xe2, 0x13, 0x50, 0x7c, 0x01, 0xaa, 0x5f, 0x4b, 0x96, 0x3d, 0xd8, 0x19, 0x0f,
+	0xa4, 0x8a, 0x5b, 0xeb, 0xf5, 0x7b, 0xbf, 0x7e, 0xff, 0xfa, 0xbd, 0xd7, 0x02, 0x48, 0x22, 0xc2,
+	0x77, 0x93, 0x34, 0x16, 0xb1, 0x73, 0x6b, 0xc4, 0xa2, 0x71, 0x9e, 0xa9, 0xaf, 0x5d, 0xb9, 0x71,
+	0xa7, 0x9d, 0x05, 0x43, 0x3a, 0x22, 0x8a, 0xe4, 0xfe, 0x59, 0x83, 0xf6, 0x33, 0xca, 0x69, 0xca,
+	0x82, 0x17, 0x24, 0xca, 0xa9, 0x73, 0x17, 0x8c, 0x41, 0x1c, 0x47, 0xfe, 0x98, 0x44, 0x9b, 0xda,
+	0xb6, 0xb6, 0x63, 0xf4, 0x6a, 0x5e, 0x4b, 0x52, 0x5e, 0x90, 0xc8, 0x79, 0x0f, 0x4c, 0xc6, 0xc5,
+	0xe3, 0x4f, 0x70, 0xb7, 0xbe, 0xad, 0xed, 0xe8, 0xbd, 0x9a, 0x67, 0x20, 0xa9, 0xd8, 0xbe, 0x88,
+	0x62, 0x22, 0x70, 0x5b, 0xdf, 0xd6, 0x76, 0x34, 0xb9, 0x8d, 0x24, 0xb9, 0xbd, 0x05, 0x90, 0x89,
+	0x94, 0xf1, 0x4b, 0xdc, 0x6f, 0x6c, 0x6b, 0x3b, 0x66, 0xaf, 0xe6, 0x99, 0x8a, 0x26, 0x19, 0x9e,
+	0x80, 0x49, 0xd2, 0x94, 0x4c, 0x70, 0xbf, 0xb9, 0xad, 0xed, 0x58, 0x8f, 0x36, 0x77, 0xff, 0xc3,
+	0x82, 0xdd, 0xae, 0xe4, 0x91, 0xc8, 0xc8, 0xfc, 0x82, 0x44, 0xfb, 0x4d, 0xd0, 0xc7, 0x24, 0x72,
+	0x7f, 0x01, 0x4d, 0xdc, 0x73, 0x3e, 0x85, 0x26, 0xee, 0x6d, 0x6a, 0xdb, 0xfa, 0x8e, 0xf5, 0x68,
+	0x6b, 0x01, 0xc8, 0xac, 0xd1, 0x9e, 0xe2, 0x76, 0xee, 0x82, 0x99, 0x91, 0x11, 0xf5, 0xc5, 0x24,
+	0xa1, 0x68, 0x9e, 0xe1, 0x19, 0x92, 0x70, 0x3e, 0x49, 0xa8, 0xfb, 0x2b, 0x0d, 0xcc, 0x9f, 0xe5,
+	0x34, 0x9d, 0xf4, 0xf9, 0x45, 0xec, 0x38, 0xd0, 0x10, 0x71, 0xf2, 0x12, 0x5d, 0xa4, 0x7b, 0xb8,
+	0x76, 0xb6, 0xc0, 0x1a, 0x51, 0x91, 0xb2, 0x40, 0x01, 0x48, 0x07, 0x98, 0x1e, 0x28, 0x92, 0x84,
+	0x70, 0xde, 0x87, 0xf5, 0x8c, 0x92, 0x34, 0x18, 0xfa, 0x09, 0x49, 0xc9, 0x28, 0x53, 0x3e, 0xf0,
+	0xda, 0x8a, 0x78, 0x8a, 0x34, 0xc9, 0x94, 0xc6, 0x39, 0x0f, 0xfd, 0x90, 0x06, 0x6c, 0x54, 0x38,
+	0x42, 0xf7, 0xda, 0x48, 0x3c, 0x54, 0x34, 0xf7, 0x9f, 0x1a, 0xc0, 0x41, 0x1c, 0xe5, 0x23, 0x8e,
+	0xda, 0xdc, 0x06, 0xe3, 0x82, 0xd1, 0x28, 0xf4, 0x59, 0x58, 0x68, 0xd4, 0xc2, 0xef, 0x7e, 0xe8,
+	0x3c, 0x05, 0x33, 0x24, 0x82, 0x54, 0x36, 0x75, 0x1e, 0xbd, 0x37, 0xef, 0x8e, 0x22, 0x1f, 0x0e,
+	0x89, 0x20, 0x52, 0x4b, 0xcf, 0x08, 0x8b, 0x95, 0xf3, 0x01, 0x74, 0x58, 0xe6, 0x27, 0x29, 0x1b,
+	0x91, 0x74, 0xe2, 0xbf, 0xa4, 0x13, 0xb4, 0xc9, 0xf0, 0xda, 0x2c, 0x3b, 0x55, 0xc4, 0xaf, 0x28,
+	0x7a, 0x8d, 0x65, 0x3e, 0xc9, 0x45, 0xdc, 0x3f, 0x44, 0x8b, 0x0c, 0xcf, 0x60, 0x59, 0x17, 0xbf,
+	0xa5, 0x4f, 0x38, 0xcd, 0x04, 0x0d, 0xfd, 0x84, 0x88, 0xe1, 0x66, 0x73, 0x5b, 0x97, 0x3e, 0x51,
+	0xa4, 0x53, 0x22, 0x86, 0xce, 0x0e, 0xd8, 0xf2, 0x0c, 0x92, 0x0a, 0x26, 0x58, 0xcc, 0xf1, 0x94,
+	0x35, 0x04, 0xe9, 0xb0, 0xec, 0xb4, 0x24, 0x7f, 0x45, 0x27, 0xee, 0x4f, 0x4a, 0x93, 0x8f, 0xde,
+	0x24, 0xa9, 0xf3, 0x11, 0x34, 0x18, 0xbf, 0x88, 0xd1, 0x5c, 0xeb, 0xaa, 0x49, 0x18, 0xe1, 0xca,
+	0x3f, 0x1e, 0xb2, 0x4a, 0x80, 0xa3, 0x37, 0x2c, 0x13, 0xd9, 0x7f, 0x0b, 0xb0, 0x0f, 0x26, 0xe6,
+	0x0b, 0xca, 0x7f, 0x0a, 0xcd, 0xb1, 0xfc, 0x28, 0x00, 0xae, 0xcf, 0x31, 0xe4, 0x76, 0x7f, 0xaf,
+	0x41, 0xe7, 0x1b, 0x4e, 0xd2, 0x89, 0x47, 0xf8, 0xa5, 0x42, 0xfa, 0x31, 0x58, 0x01, 0x1e, 0xe5,
+	0xaf, 0xae, 0x10, 0x04, 0x55, 0xf4, 0xbf, 0x0f, 0xf5, 0x38, 0x29, 0x62, 0x7b, 0x7b, 0x81, 0xd8,
+	0x49, 0x82, 0x71, 0xad, 0xc7, 0x49, 0xa5, 0xb4, 0x7e, 0x23, 0xa5, 0x7f, 0x57, 0x87, 0x8d, 0x7d,
+	0xf6, 0x6e, 0xb5, 0xfe, 0x10, 0x36, 0xa2, 0xf8, 0x35, 0x4d, 0x7d, 0xc6, 0x83, 0x28, 0xcf, 0xd8,
+	0xb8, 0xbc, 0x72, 0x1d, 0x24, 0xf7, 0x4b, 0xaa, 0x64, 0xcc, 0x93, 0x64, 0x8e, 0x51, 0xa5, 0x61,
+	0x07, 0xc9, 0x15, 0xe3, 0x1e, 0x58, 0x0a, 0x51, 0x99, 0xd8, 0x58, 0xcd, 0x44, 0x40, 0x19, 0x55,
+	0xfc, 0xf6, 0xc0, 0x52, 0x47, 0x29, 0x84, 0xe6, 0x8a, 0x08, 0x28, 0x83, 0x6b, 0xf7, 0x2f, 0x1a,
+	0x58, 0x07, 0xf1, 0x28, 0x21, 0xa9, 0xf2, 0xd2, 0x33, 0xb0, 0x23, 0x7a, 0x21, 0xfc, 0x1b, 0xbb,
+	0xaa, 0x23, 0xc5, 0x66, 0xae, 0x78, 0x1f, 0x6e, 0xa5, 0xec, 0x72, 0x38, 0x8f, 0x54, 0x5f, 0x05,
+	0x69, 0x03, 0xe5, 0x0e, 0xae, 0xe6, 0x8b, 0xbe, 0x42, 0xbe, 0xb8, 0xbf, 0xd5, 0xc0, 0x38, 0xa7,
+	0xe9, 0xe8, 0x9d, 0x44, 0xfc, 0x09, 0xac, 0xa1, 0x5f, 0xb3, 0xcd, 0xfa, 0x6a, 0x65, 0xb9, 0x60,
+	0x77, 0xee, 0x81, 0xc5, 0x32, 0x9f, 0x71, 0x1f, 0x8b, 0x5a, 0x11, 0x7d, 0x93, 0x65, 0x7d, 0xfe,
+	0xa5, 0x24, 0xb8, 0x7f, 0xaa, 0x83, 0xfd, 0xd3, 0xb3, 0x93, 0xe3, 0x83, 0x98, 0x0b, 0xc2, 0x78,
+	0xf6, 0x4e, 0xb4, 0xfd, 0x1c, 0x0c, 0x1a, 0xd1, 0x11, 0xe5, 0x62, 0x65, 0x7d, 0xa7, 0x02, 0xce,
+	0xd3, 0x19, 0x17, 0xdf, 0x5f, 0x20, 0x76, 0x55, 0x5b, 0x24, 0x9c, 0x24, 0x78, 0x47, 0x7f, 0x08,
+	0x4e, 0x89, 0xe3, 0x57, 0xed, 0x48, 0x15, 0x56, 0xbb, 0xdc, 0x39, 0x2b, 0xdb, 0xd2, 0x11, 0xac,
+	0x29, 0x59, 0xc7, 0x82, 0x56, 0x9f, 0x8f, 0x49, 0xc4, 0x42, 0xbb, 0xe6, 0xb4, 0xc1, 0x28, 0xf1,
+	0x6d, 0xcd, 0xd9, 0x90, 0x49, 0xa9, 0xbe, 0xba, 0x51, 0x64, 0xd7, 0xe7, 0x08, 0x7c, 0x62, 0xeb,
+	0xee, 0xaf, 0x35, 0x30, 0xb1, 0x2c, 0xa1, 0xef, 0x3e, 0x41, 0xf5, 0x35, 0x54, 0xff, 0x83, 0x05,
+	0xea, 0x4f, 0x39, 0xd5, 0xaa, 0x50, 0xfc, 0x01, 0x34, 0x83, 0x21, 0x8b, 0xc2, 0x22, 0x2d, 0xbf,
+	0xbd, 0x40, 0x50, 0xca, 0x78, 0x8a, 0xcb, 0xdd, 0x82, 0x56, 0x21, 0x3d, 0xaf, 0x7a, 0x0b, 0xf4,
+	0xe3, 0x58, 0xd8, 0x9a, 0xfb, 0x37, 0x0d, 0x40, 0x55, 0x1d, 0x54, 0xea, 0xf1, 0x8c, 0x52, 0xdf,
+	0x5b, 0x80, 0x5d, 0xb1, 0x16, 0xcb, 0x42, 0xad, 0x1f, 0x40, 0x43, 0xde, 0xa5, 0xeb, 0xb4, 0x42,
+	0x26, 0x69, 0x03, 0x5e, 0x97, 0xa2, 0x40, 0x2e, 0xb7, 0x01, 0xb9, 0xdc, 0xc7, 0x60, 0x94, 0x67,
+	0xcd, 0x1b, 0xd1, 0x01, 0xf8, 0x3a, 0xbe, 0x64, 0x01, 0x89, 0xba, 0x3c, 0xb4, 0x35, 0x67, 0x1d,
+	0xcc, 0xe2, 0xfb, 0x24, 0xb5, 0xeb, 0xee, 0x5f, 0x35, 0x58, 0x57, 0x82, 0xdd, 0x94, 0x89, 0xe1,
+	0x49, 0xf2, 0x3f, 0xa7, 0xeb, 0x67, 0x60, 0x10, 0x09, 0xe5, 0x4f, 0x5b, 0xc1, 0xbd, 0x85, 0xa3,
+	0x13, 0x9e, 0x86, 0xf7, 0xbb, 0x45, 0x8a, 0xa3, 0x0f, 0x61, 0x5d, 0x95, 0x96, 0x38, 0xa1, 0x29,
+	0xe1, 0xe1, 0xaa, 0xcd, 0xa1, 0x8d, 0x52, 0x27, 0x4a, 0xc8, 0xfd, 0x8d, 0x56, 0xf6, 0x08, 0x3c,
+	0x04, 0x43, 0x56, 0xba, 0x5e, 0xbb, 0x91, 0xeb, 0xeb, 0xab, 0xb8, 0xde, 0xd9, 0x9d, 0xb9, 0x62,
+	0xd7, 0x99, 0x2a, 0x4b, 0xd9, 0x1f, 0xeb, 0x70, 0x67, 0xce, 0xe5, 0x47, 0x63, 0x12, 0xbd, 0xbb,
+	0x76, 0xf6, 0xff, 0xf6, 0x7f, 0x51, 0xd5, 0x1b, 0x37, 0x9a, 0x02, 0x9a, 0x37, 0x9a, 0x02, 0x6c,
+	0xe8, 0x74, 0xa3, 0xd7, 0x64, 0x92, 0x9d, 0xa7, 0x6a, 0x06, 0x72, 0xff, 0xde, 0x82, 0x06, 0x7a,
+	0xef, 0x29, 0x98, 0x82, 0xa6, 0x23, 0x9f, 0xbe, 0x49, 0xd2, 0xc2, 0x77, 0x77, 0x17, 0xa0, 0x96,
+	0xad, 0x44, 0x0e, 0xef, 0xa2, 0x6c, 0x2b, 0x5f, 0x00, 0xe4, 0x32, 0x2c, 0x4a, 0x58, 0x05, 0xff,
+	0x3b, 0x6f, 0x2b, 0x3a, 0xf2, 0xd1, 0x90, 0x4f, 0xcb, 0xc2, 0x1e, 0x58, 0x03, 0x56, 0xc9, 0xeb,
+	0x4b, 0x03, 0x57, 0xd5, 0x87, 0x5e, 0xcd, 0x83, 0x41, 0x55, 0x58, 0x0e, 0xa0, 0x1d, 0xa8, 0x96,
+	0xad, 0x20, 0xd4, 0xe0, 0x70, 0x6f, 0x61, 0xec, 0xa7, 0x9d, 0xbd, 0x57, 0xf3, 0xac, 0x60, 0xa6,
+	0xd1, 0x3f, 0x07, 0x5b, 0x59, 0x91, 0xca, 0x94, 0x52, 0x40, 0xca, 0xbd, 0xdf, 0x5d, 0x66, 0xcb,
+	0x34, 0xf9, 0x7a, 0x35, 0xaf, 0x93, 0xcf, 0x4f, 0x57, 0xa7, 0x70, 0xab, 0xb0, 0x6a, 0x06, 0x6f,
+	0x0d, 0xf1, 0xdc, 0xa5, 0xb6, 0xcd, 0x02, 0x6e, 0x0c, 0xae, 0xcc, 0x6b, 0x02, 0xb6, 0x0a, 0xc4,
+	0x32, 0x4f, 0x7d, 0x3a, 0x26, 0xd1, 0x2c, 0x7e, 0x0b, 0xf1, 0x1f, 0x2c, 0xc5, 0x5f, 0x74, 0x71,
+	0x7a, 0x35, 0xef, 0xce, 0x60, 0xf9, 0xb5, 0xaa, 0xec, 0x50, 0xa7, 0xe2, 0x39, 0xc6, 0x35, 0x76,
+	0x4c, 0x0b, 0x48, 0x65, 0x47, 0x55, 0x53, 0xbe, 0x00, 0xc0, 0x74, 0x54, 0x50, 0xe6, 0xd2, 0x74,
+	0x99, 0x4e, 0xea, 0x32, 0x5d, 0xc6, 0xd3, 0xb1, 0x7d, 0x6f, 0x7a, 0xcf, 0x51, 0x1e, 0xae, 0xb9,
+	0xe7, 0x65, 0xba, 0x04, 0xd5, 0xcb, 0x63, 0x0f, 0x2c, 0x8a, 0xcf, 0x08, 0x85, 0x60, 0x2d, 0x45,
+	0xa8, 0x1e, 0x1b, 0x12, 0x81, 0x56, 0x4f, 0x8f, 0xe7, 0x60, 0x13, 0xbc, 0x48, 0xbe, 0x48, 0x4b,
+	0x43, 0xda, 0x4b, 0x73, 0x65, 0xfe, 0xce, 0xc9, 0x5c, 0x21, 0x73, 0x14, 0xe7, 0x0c, 0x9c, 0x5f,
+	0x66, 0x31, 0xf7, 0x83, 0xa2, 0xa3, 0x2b, 0xc0, 0x75, 0x04, 0x7c, 0x7f, 0x85, 0xe1, 0xa3, 0x57,
+	0xf3, 0x6c, 0x09, 0x30, 0x4b, 0xdb, 0x5f, 0x83, 0x86, 0x84, 0x71, 0xff, 0xa1, 0x01, 0xbc, 0xa0,
+	0x81, 0x88, 0xd3, 0xee, 0xf1, 0xf1, 0x59, 0xf1, 0xd8, 0x53, 0x31, 0x51, 0xff, 0x07, 0xe4, 0x63,
+	0x4f, 0x85, 0x6d, 0xee, 0x19, 0x5a, 0x9f, 0x7f, 0x86, 0x3e, 0x01, 0x48, 0x52, 0x1a, 0xb2, 0x80,
+	0x08, 0x9a, 0x5d, 0xd7, 0x5c, 0x67, 0x58, 0x9d, 0xcf, 0x01, 0x5e, 0xc9, 0x57, 0xb7, 0x2a, 0xcb,
+	0x8d, 0xa5, 0xe1, 0x9e, 0x3e, 0xcd, 0x3d, 0xf3, 0xd5, 0xf4, 0x95, 0xfe, 0x21, 0x6c, 0x24, 0x11,
+	0x09, 0xe8, 0x30, 0x8e, 0x42, 0x9a, 0xfa, 0x82, 0x5c, 0xe2, 0x9d, 0x34, 0xbd, 0xce, 0x0c, 0xf9,
+	0x9c, 0x5c, 0xba, 0x13, 0x58, 0x47, 0x80, 0xd3, 0x88, 0xf0, 0xe3, 0x38, 0xa4, 0x57, 0xf4, 0xd5,
+	0x56, 0xd7, 0xf7, 0x36, 0x18, 0x2c, 0xf3, 0x83, 0x38, 0xe7, 0xa2, 0x78, 0xcf, 0xb4, 0x58, 0x76,
+	0x20, 0x3f, 0x9d, 0x6f, 0x41, 0x33, 0x62, 0x23, 0xa6, 0x66, 0x0b, 0xdd, 0x53, 0x1f, 0xee, 0xbf,
+	0x34, 0x30, 0xa6, 0xc7, 0xee, 0x81, 0x35, 0x46, 0x67, 0xfb, 0x84, 0xf3, 0xec, 0x2d, 0x5d, 0xa8,
+	0x0a, 0x89, 0xcc, 0x2d, 0x25, 0xd3, 0xe5, 0x3c, 0x73, 0x3e, 0x9b, 0x53, 0xfc, 0xed, 0xad, 0x54,
+	0x8a, 0xce, 0xa8, 0xfe, 0x23, 0x68, 0xa2, 0xeb, 0x0a, 0x2f, 0x6f, 0x2f, 0xf3, 0x72, 0xa9, 0x6d,
+	0xaf, 0xe6, 0x29, 0x01, 0xf9, 0x88, 0x8f, 0x73, 0x91, 0xe4, 0xc2, 0x2f, 0xe3, 0x2f, 0x63, 0xac,
+	0xef, 0xe8, 0x5e, 0x47, 0xd1, 0xbf, 0x54, 0x69, 0x90, 0xc9, 0xb4, 0xe2, 0x71, 0x48, 0xef, 0xff,
+	0x41, 0x83, 0x35, 0xd5, 0x91, 0xe6, 0xe7, 0xa6, 0x0d, 0xb0, 0x9e, 0xa5, 0x94, 0x08, 0x9a, 0x9e,
+	0x0f, 0x09, 0xb7, 0x35, 0xc7, 0x86, 0x76, 0x41, 0x38, 0x7a, 0x95, 0x13, 0x39, 0xbb, 0xb6, 0xc1,
+	0xf8, 0x9a, 0x66, 0x19, 0xee, 0xeb, 0x38, 0x58, 0xd1, 0x2c, 0x53, 0x9b, 0x0d, 0xc7, 0x84, 0xa6,
+	0x5a, 0x36, 0x25, 0xdf, 0x71, 0x2c, 0xd4, 0xd7, 0x9a, 0x04, 0x3e, 0x4d, 0xe9, 0x05, 0x7b, 0xf3,
+	0x9c, 0x88, 0x60, 0x68, 0xb7, 0x24, 0xf0, 0x69, 0x9c, 0x89, 0x29, 0xc5, 0x90, 0xb2, 0x6a, 0x69,
+	0xca, 0x25, 0xd6, 0x30, 0x1b, 0x9c, 0x35, 0xa8, 0xf7, 0xb9, 0x6d, 0x49, 0xd2, 0x71, 0x2c, 0xfa,
+	0xdc, 0x6e, 0xdf, 0x7f, 0x06, 0xd6, 0x4c, 0x23, 0x97, 0x06, 0x7c, 0xc3, 0x5f, 0xf2, 0xf8, 0x35,
+	0x57, 0xd3, 0x6b, 0x37, 0x94, 0x13, 0x5f, 0x0b, 0xf4, 0xb3, 0x7c, 0x60, 0xd7, 0xe5, 0xe2, 0x79,
+	0x1e, 0xd9, 0xba, 0x5c, 0x1c, 0xb2, 0xb1, 0xdd, 0x40, 0x4a, 0x1c, 0xda, 0xcd, 0xfd, 0x8f, 0x7f,
+	0xfe, 0xd1, 0x25, 0x13, 0xc3, 0x7c, 0xb0, 0x1b, 0xc4, 0xa3, 0x87, 0xca, 0xdd, 0x0f, 0x58, 0x5c,
+	0xac, 0x1e, 0x32, 0x2e, 0x68, 0xca, 0x49, 0xf4, 0x10, 0x23, 0xf0, 0x50, 0x46, 0x20, 0x19, 0x0c,
+	0xd6, 0xf0, 0xeb, 0xe3, 0x7f, 0x07, 0x00, 0x00, 0xff, 0xff, 0x48, 0x4f, 0x55, 0x7b, 0xe8, 0x13,
+	0x00, 0x00,
 }

tests/integration/jsonexpr/json_expr_test.go

@@ -1023,7 +1023,7 @@ func (s *JSONExprSuite) TestJsonWithEscapeString() {
 	}
 	s.doSearch(collectionName, []string{common.MetaFieldName}, expr, dim, checkFunc)
 
-	// search fail reason: "string field contains invalid UTF-8"
+	//search fail reason: "string field contains invalid UTF-8"
 	//expr = `str4 like "abc\367-%"`
 	//checkFunc = func(result *milvuspb.SearchResults) {
 	//	s.Equal(1, len(result.Results.FieldsData))
@@ -1034,6 +1034,131 @@ func (s *JSONExprSuite) TestJsonWithEscapeString() {
 	//s.doSearch(collectionName, []string{common.MetaFieldName}, expr, dim, checkFunc)
 }
 
+func (s *JSONExprSuite) TestJsonContains() {
+	c := s.Cluster
+	ctx, cancel := context.WithCancel(c.GetContext())
+	defer cancel()
+	prefix := "TestHelloMilvus"
+	dbName := ""
+	collectionName := prefix + funcutil.GenRandomStr()
+	dim := 128
+	rowNum := 100
+
+	constructCollectionSchema := func() *schemapb.CollectionSchema {
+		pk := &schemapb.FieldSchema{
+			FieldID:      0,
+			Name:         integration.Int64Field,
+			IsPrimaryKey: true,
+			Description:  "",
+			DataType:     schemapb.DataType_Int64,
+			TypeParams:   nil,
+			IndexParams:  nil,
+			AutoID:       true,
+		}
+		fVec := &schemapb.FieldSchema{
+			FieldID:      0,
+			Name:         integration.FloatVecField,
+			IsPrimaryKey: false,
+			Description:  "",
+			DataType:     schemapb.DataType_FloatVector,
+			TypeParams: []*commonpb.KeyValuePair{
+				{
+					Key:   common.DimKey,
+					Value: strconv.Itoa(dim),
+				},
+			},
+			IndexParams: nil,
+			AutoID:      false,
+		}
+		return &schemapb.CollectionSchema{
+			Name:               collectionName,
+			Description:        "",
+			AutoID:             false,
+			EnableDynamicField: true,
+			Fields: []*schemapb.FieldSchema{
+				pk,
+				fVec,
+			},
+		}
+	}
+	schema := constructCollectionSchema()
+	marshaledSchema, err := proto.Marshal(schema)
+	s.NoError(err)
+
+	createCollectionStatus, err := c.Proxy.CreateCollection(ctx, &milvuspb.CreateCollectionRequest{
+		DbName:         dbName,
+		CollectionName: collectionName,
+		Schema:         marshaledSchema,
+		ShardsNum:      2,
+	})
+	s.NoError(err)
+	if createCollectionStatus.GetErrorCode() != commonpb.ErrorCode_Success {
+		log.Warn("createCollectionStatus fail reason", zap.String("reason", createCollectionStatus.GetReason()))
+	}
+	s.Equal(createCollectionStatus.GetErrorCode(), commonpb.ErrorCode_Success)
+
+	log.Info("CreateCollection result", zap.Any("createCollectionStatus", createCollectionStatus))
+	showCollectionsResp, err := c.Proxy.ShowCollections(ctx, &milvuspb.ShowCollectionsRequest{})
+	s.NoError(err)
+	s.Equal(showCollectionsResp.GetStatus().GetErrorCode(), commonpb.ErrorCode_Success)
+	log.Info("ShowCollections result", zap.Any("showCollectionsResp", showCollectionsResp))
+
+	describeCollectionResp, err := c.Proxy.DescribeCollection(ctx, &milvuspb.DescribeCollectionRequest{CollectionName: collectionName})
+	s.NoError(err)
+	s.True(describeCollectionResp.Schema.EnableDynamicField)
+	s.Equal(2, len(describeCollectionResp.GetSchema().GetFields()))
+
+	fVecColumn := integration.NewFloatVectorFieldData(integration.FloatVecField, rowNum, dim)
+	jsonData := newJSONData(common.MetaFieldName, rowNum)
+	jsonData.IsDynamic = true
+	s.insertFlushIndexLoad(ctx, dbName, collectionName, rowNum, dim, []*schemapb.FieldData{fVecColumn, jsonData})
+
+	expr := ""
+	// search
+	expr = `json_contains(C, 0)`
+	checkFunc := func(result *milvuspb.SearchResults) {
+		s.Equal(1, len(result.Results.FieldsData))
+		s.Equal(common.MetaFieldName, result.Results.FieldsData[0].GetFieldName())
+		s.Equal(schemapb.DataType_JSON, result.Results.FieldsData[0].GetType())
+		s.Equal(1, len(result.Results.FieldsData[0].GetScalars().GetJsonData().GetData()))
+	}
+	s.doSearch(collectionName, []string{"A"}, expr, dim, checkFunc)
+
+	expr = `json_contains_all(C, [0, 100])`
+	checkFunc = func(result *milvuspb.SearchResults) {
+		s.Equal(1, len(result.Results.FieldsData))
+		s.Equal(common.MetaFieldName, result.Results.FieldsData[0].GetFieldName())
+		s.Equal(schemapb.DataType_JSON, result.Results.FieldsData[0].GetType())
+		s.Equal(1, len(result.Results.FieldsData[0].GetScalars().GetJsonData().GetData()))
+	}
+	s.doSearch(collectionName, []string{"A"}, expr, dim, checkFunc)
+
+	expr = `json_contains_all(C, [0, 99])`
+	checkFunc = func(result *milvuspb.SearchResults) {
+		for _, f := range result.Results.GetFieldsData() {
+			s.Nil(f)
+		}
+	}
+	s.doSearch(collectionName, []string{"A"}, expr, dim, checkFunc)
+
+	expr = `json_contains_any(C, [1, 98])`
+	checkFunc = func(result *milvuspb.SearchResults) {
+		s.Equal(1, len(result.Results.FieldsData))
+		s.Equal(common.MetaFieldName, result.Results.FieldsData[0].GetFieldName())
+		s.Equal(schemapb.DataType_JSON, result.Results.FieldsData[0].GetType())
+		s.Equal(4, len(result.Results.FieldsData[0].GetScalars().GetJsonData().GetData()))
+	}
+	s.doSearch(collectionName, []string{"A"}, expr, dim, checkFunc)
+
+	expr = `json_contains_any(C, [101, 102])`
+	checkFunc = func(result *milvuspb.SearchResults) {
+		for _, f := range result.Results.GetFieldsData() {
+			s.Nil(f)
+		}
+	}
+	s.doSearch(collectionName, []string{"A"}, expr, dim, checkFunc)
+}
+
 func TestJsonExpr(t *testing.T) {
 	suite.Run(t, new(JSONExprSuite))
 }