feat: support LeafFunction of StartsWith, EndsWith, Contains, Like

Author: SteNicholas

include/paimon/predicate/function.h

@@ -37,7 +37,11 @@ class PAIMON_EXPORT Function {
         IN = 9,
         NOT_IN = 10,
         AND = 11,
-        OR = 12
+        OR = 12,
+        STARTS_WITH = 13,
+        ENDS_WITH = 14,
+        CONTAINS = 15,
+        LIKE = 16
     };
     virtual ~Function() = default;
     virtual Type GetType() const = 0;

include/paimon/predicate/predicate_builder.h

@@ -133,5 +133,30 @@ class PAIMON_EXPORT PredicateBuilder {
     ///
     /// @param predicate A shared pointer to the predicate to be negated, which must not be nullptr.
     static Result<std::shared_ptr<Predicate>> Not(const std::shared_ptr<Predicate>& predicate);
+
+    /// Create a starts-with predicate (field like 'abc%' or field like 'abc_').
+    ///
+    /// Tests whether the field value starts with the provided literal value.
+    static std::shared_ptr<Predicate> StartsWith(int32_t field_index, const std::string& field_name,
+                                                 const FieldType& field_type,
+                                                 const Literal& literal);
+
+    /// Create an ends-with predicate (field like '%abc' or field like '_abc').
+    ///
+    /// Tests whether the field value ends with the provided literal value.
+    static std::shared_ptr<Predicate> EndsWith(int32_t field_index, const std::string& field_name,
+                                               const FieldType& field_type, const Literal& literal);
+
+    /// Create a contains predicate (field like '%abc%').
+    ///
+    /// Tests whether the field value contains the provided literal value.
+    static std::shared_ptr<Predicate> Contains(int32_t field_index, const std::string& field_name,
+                                               const FieldType& field_type, const Literal& literal);
+
+    /// Create a like predicate (field like literal).
+    ///
+    /// Tests whether the field value like the provided literal value.
+    static std::shared_ptr<Predicate> Like(int32_t field_index, const std::string& field_name,
+                                           const FieldType& field_type, const Literal& literal);
 };
 }  // namespace paimon

src/paimon/common/predicate/contains.h

@@ -0,0 +1,48 @@
+/*
+ * Copyright 2026-present Alibaba Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <string>
+
+#include "paimon/common/predicate/string_leaf_binary_function.h"
+#include "paimon/result.h"
+
+namespace paimon {
+/// A `StringLeafBinaryFunction` to eval filter like '%abc%'.
+class Contains : public StringLeafBinaryFunction {
+ public:
+    static const Contains& Instance() {
+        static const Contains instance = Contains();
+        return instance;
+    }
+
+    Result<bool> TestString(const std::string& field, const std::string& pattern) const override {
+        return field.find(pattern) != std::string::npos;
+    }
+
+    Type GetType() const override {
+        return Type::CONTAINS;
+    }
+
+    std::string ToString() const override {
+        return "Contains";
+    }
+
+ private:
+    Contains() = default;
+};
+}  // namespace paimon

src/paimon/common/predicate/ends_with.h

@@ -0,0 +1,49 @@
+/*
+ * Copyright 2026-present Alibaba Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <string>
+
+#include "paimon/common/predicate/string_leaf_binary_function.h"
+#include "paimon/result.h"
+
+namespace paimon {
+/// A `StringLeafBinaryFunction` to eval filter like '%abc' or filter like '_abc'.
+class EndsWith : public StringLeafBinaryFunction {
+ public:
+    static const EndsWith& Instance() {
+        static const EndsWith instance = EndsWith();
+        return instance;
+    }
+
+    Result<bool> TestString(const std::string& field, const std::string& pattern) const override {
+        return field.size() >= pattern.size() &&
+               std::equal(pattern.rbegin(), pattern.rend(), field.rbegin());
+    }
+
+    Type GetType() const override {
+        return Type::ENDS_WITH;
+    }
+
+    std::string ToString() const override {
+        return "EndsWith";
+    }
+
+ private:
+    EndsWith() = default;
+};
+}  // namespace paimon

src/paimon/common/predicate/equal.cpp

@@ -21,8 +21,8 @@
 namespace paimon {
 class LeafFunction;
 
-const LeafFunction& Equal::Negate() const {
-    return NotEqual::Instance();
+const LeafFunction* Equal::Negate() const {
+    return &NotEqual::Instance();
 }
 
 }  // namespace paimon

src/paimon/common/predicate/equal.h

@@ -52,7 +52,7 @@ class Equal : public NullFalseLeafBinaryFunction {
     Type GetType() const override {
         return Type::EQUAL;
     }
-    const LeafFunction& Negate() const override;
+    const LeafFunction* Negate() const override;
     std::string ToString() const override {
         return "Equal";
     }

src/paimon/common/predicate/greater_or_equal.cpp

@@ -21,8 +21,8 @@
 namespace paimon {
 class LeafFunction;
 
-const LeafFunction& GreaterOrEqual::Negate() const {
-    return LessThan::Instance();
+const LeafFunction* GreaterOrEqual::Negate() const {
+    return &LessThan::Instance();
 }
 
 }  // namespace paimon

src/paimon/common/predicate/greater_or_equal.h

@@ -49,7 +49,7 @@ class GreaterOrEqual : public NullFalseLeafBinaryFunction {
     Type GetType() const override {
         return Type::GREATER_OR_EQUAL;
     }
-    const LeafFunction& Negate() const override;
+    const LeafFunction* Negate() const override;
     std::string ToString() const override {
         return "GreaterOrEqual";
     }

src/paimon/common/predicate/greater_than.cpp

@@ -26,7 +26,7 @@ const GreaterThan& GreaterThan::Instance() {
     return kInstance;
 }
 
-const LeafFunction& GreaterThan::Negate() const {
-    return LessOrEqual::Instance();
+const LeafFunction* GreaterThan::Negate() const {
+    return &LessOrEqual::Instance();
 }
 }  // namespace paimon

src/paimon/common/predicate/greater_than.h

@@ -46,7 +46,7 @@ class GreaterThan : public NullFalseLeafBinaryFunction {
     Type GetType() const override {
         return Type::GREATER_THAN;
     }
-    const LeafFunction& Negate() const override;
+    const LeafFunction* Negate() const override;
 
     std::string ToString() const override {
         return "GreaterThan";