Support json contains feature (#25384)

Signed-off-by: Ncai.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_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]
\ No newline at end of file

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_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/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;
   };
 }