feat(PostgreSQL): 增加数组类型字段支持

hsweb-easy-orm-core/src/main/java/org/hswebframework/ezorm/core/Conditional.java

@@ -869,6 +869,132 @@ default <B> T notIn(StaticMethodReferenceColumn<B> column, Collection<?> values)
         return accept(column, TermType.nin, values);
     }
 
+    /**
+     * 追加包含条件（静态方法引用方式）: column contains ?
+     *
+     * @param column 列引用
+     * @param value  条件值
+     * @return 当前条件构造器
+     */
+    default <B> T contains(StaticMethodReferenceColumn<B> column, Object value) {
+        return accept(column, TermType.contains, value);
+    }
+
+    /**
+     * 追加包含条件（方法引用方式）: column contains ?
+     *
+     * @param column 列引用
+     * @return 当前条件构造器
+     */
+    default <B> T contains(MethodReferenceColumn<B> column) {
+        return accept(column, TermType.contains);
+    }
+
+    /**
+     * 追加不包含条件（静态方法引用方式）: column not contains ?
+     *
+     * @param column 列引用
+     * @param value  条件值
+     * @return 当前条件构造器
+     */
+    default <B> T notContains(StaticMethodReferenceColumn<B> column, Object value) {
+        return accept(column, TermType.ncontains, value);
+    }
+
+    /**
+     * 追加不包含条件（方法引用方式）: column not contains ?
+     *
+     * @param column 列引用
+     * @return 当前条件构造器
+     */
+    default <B> T notContains(MethodReferenceColumn<B> column) {
+        return accept(column, TermType.ncontains);
+    }
+
+    /**
+     * 追加被包含条件（静态方法引用方式）: column contained by ?
+     *
+     * @param column 列引用
+     * @param value  条件值
+     * @return 当前条件构造器
+     */
+    default <B> T contained(StaticMethodReferenceColumn<B> column, Object value) {
+        return accept(column, TermType.contained, value);
+    }
+
+    /**
+     * 追加被包含条件（方法引用方式）: column contained by ?
+     *
+     * @param column 列引用
+     * @return 当前条件构造器
+     */
+    default <B> T contained(MethodReferenceColumn<B> column) {
+        return accept(column, TermType.contained);
+    }
+
+    /**
+     * 追加不被包含条件（静态方法引用方式）: column not contained by ?
+     *
+     * @param column 列引用
+     * @param value  条件值
+     * @return 当前条件构造器
+     */
+    default <B> T notContained(StaticMethodReferenceColumn<B> column, Object value) {
+        return accept(column, TermType.ncontained, value);
+    }
+
+    /**
+     * 追加不被包含条件（方法引用方式）: column not contained by ?
+     *
+     * @param column 列引用
+     * @return 当前条件构造器
+     */
+    default <B> T notContained(MethodReferenceColumn<B> column) {
+        return accept(column, TermType.ncontained);
+    }
+
+    /**
+     * 追加相交条件（静态方法引用方式）: column overlap ?
+     *
+     * @param column 列引用
+     * @param value  条件值
+     * @return 当前条件构造器
+     */
+    default <B> T overlap(StaticMethodReferenceColumn<B> column, Object value) {
+        return accept(column, TermType.overlap, value);
+    }
+
+    /**
+     * 追加相交条件（方法引用方式）: column overlap ?
+     *
+     * @param column 列引用
+     * @return 当前条件构造器
+     */
+    default <B> T overlap(MethodReferenceColumn<B> column) {
+        return accept(column, TermType.overlap);
+    }
+
+    /**
+     * 追加不相交条件（静态方法引用方式）: column not overlap ?
+     *
+     * @param column 列引用
+     * @param value  条件值
+     * @return 当前条件构造器
+     */
+    default <B> T notOverlap(StaticMethodReferenceColumn<B> column, Object value) {
+        return accept(column, TermType.noverlap, value);
+    }
+
+    /**
+     * 追加不相交条件（方法引用方式）: column not overlap ?
+     *
+     * @param column 列引用
+     * @return 当前条件构造器
+     */
+    default <B> T notOverlap(MethodReferenceColumn<B> column) {
+        return accept(column, TermType.noverlap);
+    }
+
     /**
      * 追加为空条件（静态方法引用方式）: column = ''
      *

hsweb-easy-orm-core/src/main/java/org/hswebframework/ezorm/core/NestConditional.java

@@ -685,6 +685,132 @@ default <B> NestConditional<T> notIn(MethodReferenceColumn<B> column) {
         return accept(column, TermType.nin);
     }
 
+    /**
+     * 追加包含条件（方法引用方式）: column contains ?
+     *
+     * @param column 列引用
+     * @param value  条件值
+     * @return 当前嵌套条件构造器
+     */
+    default <B> NestConditional<T> contains(StaticMethodReferenceColumn<B> column, Object value) {
+        return accept(column, TermType.contains, value);
+    }
+
+    /**
+     * 追加包含条件（方法引用方式）: column contains ?
+     *
+     * @param column 列引用
+     * @return 当前嵌套条件构造器
+     */
+    default <B> NestConditional<T> contains(MethodReferenceColumn<B> column) {
+        return accept(column, TermType.contains);
+    }
+
+    /**
+     * 追加不包含条件（方法引用方式）: column not contains ?
+     *
+     * @param column 列引用
+     * @param value  条件值
+     * @return 当前嵌套条件构造器
+     */
+    default <B> NestConditional<T> notContains(StaticMethodReferenceColumn<B> column, Object value) {
+        return accept(column, TermType.ncontains, value);
+    }
+
+    /**
+     * 追加不包含条件（方法引用方式）: column not contains ?
+     *
+     * @param column 列引用
+     * @return 当前嵌套条件构造器
+     */
+    default <B> NestConditional<T> notContains(MethodReferenceColumn<B> column) {
+        return accept(column, TermType.ncontains);
+    }
+
+    /**
+     * 追加被包含条件（方法引用方式）: column contained by ?
+     *
+     * @param column 列引用
+     * @param value  条件值
+     * @return 当前嵌套条件构造器
+     */
+    default <B> NestConditional<T> contained(StaticMethodReferenceColumn<B> column, Object value) {
+        return accept(column, TermType.contained, value);
+    }
+
+    /**
+     * 追加被包含条件（方法引用方式）: column contained by ?
+     *
+     * @param column 列引用
+     * @return 当前嵌套条件构造器
+     */
+    default <B> NestConditional<T> contained(MethodReferenceColumn<B> column) {
+        return accept(column, TermType.contained);
+    }
+
+    /**
+     * 追加不被包含条件（方法引用方式）: column not contained by ?
+     *
+     * @param column 列引用
+     * @param value  条件值
+     * @return 当前嵌套条件构造器
+     */
+    default <B> NestConditional<T> notContained(StaticMethodReferenceColumn<B> column, Object value) {
+        return accept(column, TermType.ncontained, value);
+    }
+
+    /**
+     * 追加不被包含条件（方法引用方式）: column not contained by ?
+     *
+     * @param column 列引用
+     * @return 当前嵌套条件构造器
+     */
+    default <B> NestConditional<T> notContained(MethodReferenceColumn<B> column) {
+        return accept(column, TermType.ncontained);
+    }
+
+    /**
+     * 追加相交条件（方法引用方式）: column overlap ?
+     *
+     * @param column 列引用
+     * @param value  条件值
+     * @return 当前嵌套条件构造器
+     */
+    default <B> NestConditional<T> overlap(StaticMethodReferenceColumn<B> column, Object value) {
+        return accept(column, TermType.overlap, value);
+    }
+
+    /**
+     * 追加相交条件（方法引用方式）: column overlap ?
+     *
+     * @param column 列引用
+     * @return 当前嵌套条件构造器
+     */
+    default <B> NestConditional<T> overlap(MethodReferenceColumn<B> column) {
+        return accept(column, TermType.overlap);
+    }
+
+    /**
+     * 追加不相交条件（方法引用方式）: column not overlap ?
+     *
+     * @param column 列引用
+     * @param value  条件值
+     * @return 当前嵌套条件构造器
+     */
+    default <B> NestConditional<T> notOverlap(StaticMethodReferenceColumn<B> column, Object value) {
+        return accept(column, TermType.noverlap, value);
+    }
+
+    /**
+     * 追加不相交条件（方法引用方式）: column not overlap ?
+     *
+     * @param column 列引用
+     * @return 当前嵌套条件构造器
+     */
+    default <B> NestConditional<T> notOverlap(MethodReferenceColumn<B> column) {
+        return accept(column, TermType.noverlap);
+    }
+
     /**
      * 追加为空条件（方法引用方式）: column = '' or column is null
      * 

hsweb-easy-orm-core/src/main/java/org/hswebframework/ezorm/core/param/TermType.java

@@ -120,4 +120,46 @@ public interface TermType {
      */
     String nbtw    = "nbtw";
 
+    /**
+     * contains
+     *
+     * @since 4.2
+     */
+    String contains = "contains";
+
+    /**
+     * not contains
+     *
+     * @since 4.2
+     */
+    String ncontains = "ncontains";
+
+    /**
+     * contained by
+     *
+     * @since 4.2
+     */
+    String contained = "contained";
+
+    /**
+     * not contained by
+     *
+     * @since 4.2
+     */
+    String ncontained = "ncontained";
+
+    /**
+     * overlap
+     *
+     * @since 4.2
+     */
+    String overlap = "overlap";
+
+    /**
+     * not overlap
+     *
+     * @since 4.2
+     */
+    String noverlap = "noverlap";
+
 }

hsweb-easy-orm-core/src/test/java/org/hswebframework/ezorm/core/dsl/QueryTest.java

@@ -55,6 +55,16 @@ public void testWhere() {
             assertSingleCondition(query -> query.in(TestEntity::getId, Arrays.asList(1, 2, 3)), "in",  Arrays.asList(1, 2, 3));
         }
 
+        //array-like terms
+        {
+            assertSingleCondition(query -> query.contains(TestEntity::getId, 1), "contains", 1);
+            assertSingleCondition(query -> query.notContains(TestEntity::getId, 1), "ncontains", 1);
+            assertSingleCondition(query -> query.contained(TestEntity::getId, 1), "contained", 1);
+            assertSingleCondition(query -> query.notContained(TestEntity::getId, 1), "ncontained", 1);
+            assertSingleCondition(query -> query.overlap(TestEntity::getId, 1), "overlap", 1);
+            assertSingleCondition(query -> query.notOverlap(TestEntity::getId, 1), "noverlap", 1);
+        }
+
         //gt lt
         {
             assertSingleCondition(query -> query.gt(TestEntity::getId, 1), "gt", 1);
@@ -85,4 +95,4 @@ static class TestEntity implements Serializable {
         String id;
         String name;
     }
-}
+}

hsweb-easy-orm-rdb/pom.xml

@@ -139,7 +139,7 @@
         <dependency>
             <groupId>org.testcontainers</groupId>
             <artifactId>testcontainers</artifactId>
-            <version>1.17.1</version>
+            <version>1.21.4</version>
             <scope>test</scope>
         </dependency>
 

hsweb-easy-orm-rdb/src/main/java/org/hswebframework/ezorm/rdb/executor/JdbcParameterBinder.java

@@ -0,0 +1,9 @@
+package org.hswebframework.ezorm.rdb.executor;
+
+import java.sql.PreparedStatement;
+import java.sql.SQLException;
+
+public interface JdbcParameterBinder {
+
+    void bind(PreparedStatement statement, int index) throws SQLException;
+}

hsweb-easy-orm-rdb/src/main/java/org/hswebframework/ezorm/rdb/executor/R2dbcParameterBinder.java

@@ -0,0 +1,8 @@
+package org.hswebframework.ezorm.rdb.executor;
+
+import io.r2dbc.spi.Statement;
+
+public interface R2dbcParameterBinder {
+
+    void bind(Statement statement, String identifier);
+}

hsweb-easy-orm-rdb/src/main/java/org/hswebframework/ezorm/rdb/executor/jdbc/JdbcSqlExecutorHelper.java

@@ -2,6 +2,7 @@
 
 import lombok.SneakyThrows;
 import org.hswebframework.ezorm.rdb.codec.LongCharSequence;
+import org.hswebframework.ezorm.rdb.executor.JdbcParameterBinder;
 import org.hswebframework.ezorm.rdb.executor.NullValue;
 
 import java.io.ByteArrayInputStream;
@@ -37,8 +38,14 @@ protected static void preparedStatementParameter(PreparedStatement statement, Ob
         for (Object object : parameter) {
             if (object == null) {
                 statement.setNull(index++, Types.NULL);
+            } else if (object instanceof JdbcParameterBinder binder) {
+                binder.bind(statement, index++);
             } else if (object instanceof NullValue nullValue) {
-                statement.setNull(index++, nullValue.getDataType().getSqlType().getVendorTypeNumber());
+                int sqlType = nullValue.getDataType().getSqlType().getVendorTypeNumber();
+                if (nullValue.getType() == LongCharSequence.class) {
+                    sqlType = Types.LONGVARCHAR;
+                }
+                statement.setNull(index++, sqlType);
             } else if (object instanceof Date) {
                 statement.setTimestamp(index++, new java.sql.Timestamp(((Date) object).getTime()));
             } else if (object instanceof byte[] b) {