创建简单的 JdbcUtil，并借助 MyBatis 的 SQL 构建器简化 SQL 的拼接。

pom.xml

@@ -49,6 +49,19 @@
             <version>5.9.2</version>
             <scope>test</scope>
         </dependency>
+
+        <dependency>
+            <groupId>com.zaxxer</groupId>
+            <artifactId>HikariCP</artifactId>
+            <version>4.0.3</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.postgresql</groupId>
+            <artifactId>postgresql</artifactId>
+            <version>42.3.8</version>
+            <scope>test</scope>
+        </dependency>
     </dependencies>
 
     <build>

src/main/java/org/apache/ibatis/jdbc/AbstractSQL.java

@@ -0,0 +1,740 @@
+/*
+ *    Copyright 2009-2023 the original author or authors.
+ *
+ *    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
+ *
+ *       https://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.
+ */
+package org.apache.ibatis.jdbc;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * @author Clinton Begin
+ * @author Jeff Butler
+ * @author Adam Gent
+ * @author Kazuki Shimizu
+ */
+public abstract class AbstractSQL<T> {
+
+  private static final String AND = ") \nAND (";
+  private static final String OR = ") \nOR (";
+
+  private final SQLStatement sql = new SQLStatement();
+
+  public abstract T getSelf();
+
+  public T UPDATE(String table) {
+    sql().statementType = SQLStatement.StatementType.UPDATE;
+    sql().tables.add(table);
+    return getSelf();
+  }
+
+  public T SET(String sets) {
+    sql().sets.add(sets);
+    return getSelf();
+  }
+
+  /**
+   * Sets the.
+   *
+   * @param sets
+   *          the sets
+   *
+   * @return the t
+   *
+   * @since 3.4.2
+   */
+  public T SET(String... sets) {
+    sql().sets.addAll(Arrays.asList(sets));
+    return getSelf();
+  }
+
+  public T INSERT_INTO(String tableName) {
+    sql().statementType = SQLStatement.StatementType.INSERT;
+    sql().tables.add(tableName);
+    return getSelf();
+  }
+
+  public T VALUES(String columns, String values) {
+    INTO_COLUMNS(columns);
+    INTO_VALUES(values);
+    return getSelf();
+  }
+
+  /**
+   * Into columns.
+   *
+   * @param columns
+   *          the columns
+   *
+   * @return the t
+   *
+   * @since 3.4.2
+   */
+  public T INTO_COLUMNS(String... columns) {
+    sql().columns.addAll(Arrays.asList(columns));
+    return getSelf();
+  }
+
+  /**
+   * Into values.
+   *
+   * @param values
+   *          the values
+   *
+   * @return the t
+   *
+   * @since 3.4.2
+   */
+  public T INTO_VALUES(String... values) {
+    List<String> list = sql().valuesList.get(sql().valuesList.size() - 1);
+    Collections.addAll(list, values);
+    return getSelf();
+  }
+
+  public T SELECT(String columns) {
+    sql().statementType = SQLStatement.StatementType.SELECT;
+    sql().select.add(columns);
+    return getSelf();
+  }
+
+  /**
+   * Select.
+   *
+   * @param columns
+   *          the columns
+   *
+   * @return the t
+   *
+   * @since 3.4.2
+   */
+  public T SELECT(String... columns) {
+    sql().statementType = SQLStatement.StatementType.SELECT;
+    sql().select.addAll(Arrays.asList(columns));
+    return getSelf();
+  }
+
+  public T SELECT_DISTINCT(String columns) {
+    sql().distinct = true;
+    SELECT(columns);
+    return getSelf();
+  }
+
+  /**
+   * Select distinct.
+   *
+   * @param columns
+   *          the columns
+   *
+   * @return the t
+   *
+   * @since 3.4.2
+   */
+  public T SELECT_DISTINCT(String... columns) {
+    sql().distinct = true;
+    SELECT(columns);
+    return getSelf();
+  }
+
+  public T DELETE_FROM(String table) {
+    sql().statementType = SQLStatement.StatementType.DELETE;
+    sql().tables.add(table);
+    return getSelf();
+  }
+
+  public T FROM(String table) {
+    sql().tables.add(table);
+    return getSelf();
+  }
+
+  /**
+   * From.
+   *
+   * @param tables
+   *          the tables
+   *
+   * @return the t
+   *
+   * @since 3.4.2
+   */
+  public T FROM(String... tables) {
+    sql().tables.addAll(Arrays.asList(tables));
+    return getSelf();
+  }
+
+  public T JOIN(String join) {
+    sql().join.add(join);
+    return getSelf();
+  }
+
+  /**
+   * Join.
+   *
+   * @param joins
+   *          the joins
+   *
+   * @return the t
+   *
+   * @since 3.4.2
+   */
+  public T JOIN(String... joins) {
+    sql().join.addAll(Arrays.asList(joins));
+    return getSelf();
+  }
+
+  public T INNER_JOIN(String join) {
+    sql().innerJoin.add(join);
+    return getSelf();
+  }
+
+  /**
+   * Inner join.
+   *
+   * @param joins
+   *          the joins
+   *
+   * @return the t
+   *
+   * @since 3.4.2
+   */
+  public T INNER_JOIN(String... joins) {
+    sql().innerJoin.addAll(Arrays.asList(joins));
+    return getSelf();
+  }
+
+  public T LEFT_OUTER_JOIN(String join) {
+    sql().leftOuterJoin.add(join);
+    return getSelf();
+  }
+
+  /**
+   * Left outer join.
+   *
+   * @param joins
+   *          the joins
+   *
+   * @return the t
+   *
+   * @since 3.4.2
+   */
+  public T LEFT_OUTER_JOIN(String... joins) {
+    sql().leftOuterJoin.addAll(Arrays.asList(joins));
+    return getSelf();
+  }
+
+  public T RIGHT_OUTER_JOIN(String join) {
+    sql().rightOuterJoin.add(join);
+    return getSelf();
+  }
+
+  /**
+   * Right outer join.
+   *
+   * @param joins
+   *          the joins
+   *
+   * @return the t
+   *
+   * @since 3.4.2
+   */
+  public T RIGHT_OUTER_JOIN(String... joins) {
+    sql().rightOuterJoin.addAll(Arrays.asList(joins));
+    return getSelf();
+  }
+
+  public T OUTER_JOIN(String join) {
+    sql().outerJoin.add(join);
+    return getSelf();
+  }
+
+  /**
+   * Outer join.
+   *
+   * @param joins
+   *          the joins
+   *
+   * @return the t
+   *
+   * @since 3.4.2
+   */
+  public T OUTER_JOIN(String... joins) {
+    sql().outerJoin.addAll(Arrays.asList(joins));
+    return getSelf();
+  }
+
+  public T WHERE(String conditions) {
+    sql().where.add(conditions);
+    sql().lastList = sql().where;
+    return getSelf();
+  }
+
+  /**
+   * Where.
+   *
+   * @param conditions
+   *          the conditions
+   *
+   * @return the t
+   *
+   * @since 3.4.2
+   */
+  public T WHERE(String... conditions) {
+    sql().where.addAll(Arrays.asList(conditions));
+    sql().lastList = sql().where;
+    return getSelf();
+  }
+
+  public T OR() {
+    sql().lastList.add(OR);
+    return getSelf();
+  }
+
+  public T AND() {
+    sql().lastList.add(AND);
+    return getSelf();
+  }
+
+  public T GROUP_BY(String columns) {
+    sql().groupBy.add(columns);
+    return getSelf();
+  }
+
+  /**
+   * Group by.
+   *
+   * @param columns
+   *          the columns
+   *
+   * @return the t
+   *
+   * @since 3.4.2
+   */
+  public T GROUP_BY(String... columns) {
+    sql().groupBy.addAll(Arrays.asList(columns));
+    return getSelf();
+  }
+
+  public T HAVING(String conditions) {
+    sql().having.add(conditions);
+    sql().lastList = sql().having;
+    return getSelf();
+  }
+
+  /**
+   * Having.
+   *
+   * @param conditions
+   *          the conditions
+   *
+   * @return the t
+   *
+   * @since 3.4.2
+   */
+  public T HAVING(String... conditions) {
+    sql().having.addAll(Arrays.asList(conditions));
+    sql().lastList = sql().having;
+    return getSelf();
+  }
+
+  public T ORDER_BY(String columns) {
+    sql().orderBy.add(columns);
+    return getSelf();
+  }
+
+  /**
+   * Order by.
+   *
+   * @param columns
+   *          the columns
+   *
+   * @return the t
+   *
+   * @since 3.4.2
+   */
+  public T ORDER_BY(String... columns) {
+    sql().orderBy.addAll(Arrays.asList(columns));
+    return getSelf();
+  }
+
+  /**
+   * Set the limit variable string(e.g. {@code "#{limit}"}).
+   *
+   * @param variable
+   *          a limit variable string
+   *
+   * @return a self instance
+   *
+   * @see #OFFSET(String)
+   *
+   * @since 3.5.2
+   */
+  public T LIMIT(String variable) {
+    sql().limit = variable;
+    sql().limitingRowsStrategy = SQLStatement.LimitingRowsStrategy.OFFSET_LIMIT;
+    return getSelf();
+  }
+
+  /**
+   * Set the limit value.
+   *
+   * @param value
+   *          an offset value
+   *
+   * @return a self instance
+   *
+   * @see #OFFSET(long)
+   *
+   * @since 3.5.2
+   */
+  public T LIMIT(int value) {
+    return LIMIT(String.valueOf(value));
+  }
+
+  /**
+   * Set the offset variable string(e.g. {@code "#{offset}"}).
+   *
+   * @param variable
+   *          a offset variable string
+   *
+   * @return a self instance
+   *
+   * @see #LIMIT(String)
+   *
+   * @since 3.5.2
+   */
+  public T OFFSET(String variable) {
+    sql().offset = variable;
+    sql().limitingRowsStrategy = SQLStatement.LimitingRowsStrategy.OFFSET_LIMIT;
+    return getSelf();
+  }
+
+  /**
+   * Set the offset value.
+   *
+   * @param value
+   *          an offset value
+   *
+   * @return a self instance
+   *
+   * @see #LIMIT(int)
+   *
+   * @since 3.5.2
+   */
+  public T OFFSET(long value) {
+    return OFFSET(String.valueOf(value));
+  }
+
+  /**
+   * Set the fetch first rows variable string(e.g. {@code "#{fetchFirstRows}"}).
+   *
+   * @param variable
+   *          a fetch first rows variable string
+   *
+   * @return a self instance
+   *
+   * @see #OFFSET_ROWS(String)
+   *
+   * @since 3.5.2
+   */
+  public T FETCH_FIRST_ROWS_ONLY(String variable) {
+    sql().limit = variable;
+    sql().limitingRowsStrategy = SQLStatement.LimitingRowsStrategy.ISO;
+    return getSelf();
+  }
+
+  /**
+   * Set the fetch first rows value.
+   *
+   * @param value
+   *          a fetch first rows value
+   *
+   * @return a self instance
+   *
+   * @see #OFFSET_ROWS(long)
+   *
+   * @since 3.5.2
+   */
+  public T FETCH_FIRST_ROWS_ONLY(int value) {
+    return FETCH_FIRST_ROWS_ONLY(String.valueOf(value));
+  }
+
+  /**
+   * Set the offset rows variable string(e.g. {@code "#{offset}"}).
+   *
+   * @param variable
+   *          a offset rows variable string
+   *
+   * @return a self instance
+   *
+   * @see #FETCH_FIRST_ROWS_ONLY(String)
+   *
+   * @since 3.5.2
+   */
+  public T OFFSET_ROWS(String variable) {
+    sql().offset = variable;
+    sql().limitingRowsStrategy = SQLStatement.LimitingRowsStrategy.ISO;
+    return getSelf();
+  }
+
+  /**
+   * Set the offset rows value.
+   *
+   * @param value
+   *          an offset rows value
+   *
+   * @return a self instance
+   *
+   * @see #FETCH_FIRST_ROWS_ONLY(int)
+   *
+   * @since 3.5.2
+   */
+  public T OFFSET_ROWS(long value) {
+    return OFFSET_ROWS(String.valueOf(value));
+  }
+
+  /**
+   * used to add a new inserted row while do multi-row insert.
+   *
+   * @return the t
+   *
+   * @since 3.5.2
+   */
+  public T ADD_ROW() {
+    sql().valuesList.add(new ArrayList<>());
+    return getSelf();
+  }
+
+  private SQLStatement sql() {
+    return sql;
+  }
+
+  public <A extends Appendable> A usingAppender(A a) {
+    sql().sql(a);
+    return a;
+  }
+
+  @Override
+  public String toString() {
+    StringBuilder sb = new StringBuilder();
+    sql().sql(sb);
+    return sb.toString();
+  }
+
+  private static class SafeAppendable {
+    private final Appendable appendable;
+    private boolean empty = true;
+
+    public SafeAppendable(Appendable a) {
+      this.appendable = a;
+    }
+
+    public SafeAppendable append(CharSequence s) {
+      try {
+        if (empty && s.length() > 0) {
+          empty = false;
+        }
+        appendable.append(s);
+      } catch (IOException e) {
+        throw new RuntimeException(e);
+      }
+      return this;
+    }
+
+    public boolean isEmpty() {
+      return empty;
+    }
+
+  }
+
+  private static class SQLStatement {
+
+    public enum StatementType {
+
+      DELETE,
+
+      INSERT,
+
+      SELECT,
+
+      UPDATE
+
+    }
+
+    private enum LimitingRowsStrategy {
+      NOP {
+        @Override
+        protected void appendClause(SafeAppendable builder, String offset, String limit) {
+          // NOP
+        }
+      },
+      ISO {
+        @Override
+        protected void appendClause(SafeAppendable builder, String offset, String limit) {
+          if (offset != null) {
+            builder.append(" OFFSET ").append(offset).append(" ROWS");
+          }
+          if (limit != null) {
+            builder.append(" FETCH FIRST ").append(limit).append(" ROWS ONLY");
+          }
+        }
+      },
+      OFFSET_LIMIT {
+        @Override
+        protected void appendClause(SafeAppendable builder, String offset, String limit) {
+          if (limit != null) {
+            builder.append(" LIMIT ").append(limit);
+          }
+          if (offset != null) {
+            builder.append(" OFFSET ").append(offset);
+          }
+        }
+      };
+
+      protected abstract void appendClause(SafeAppendable builder, String offset, String limit);
+
+    }
+
+    StatementType statementType;
+    List<String> sets = new ArrayList<>();
+    List<String> select = new ArrayList<>();
+    List<String> tables = new ArrayList<>();
+    List<String> join = new ArrayList<>();
+    List<String> innerJoin = new ArrayList<>();
+    List<String> outerJoin = new ArrayList<>();
+    List<String> leftOuterJoin = new ArrayList<>();
+    List<String> rightOuterJoin = new ArrayList<>();
+    List<String> where = new ArrayList<>();
+    List<String> having = new ArrayList<>();
+    List<String> groupBy = new ArrayList<>();
+    List<String> orderBy = new ArrayList<>();
+    List<String> lastList = new ArrayList<>();
+    List<String> columns = new ArrayList<>();
+    List<List<String>> valuesList = new ArrayList<>();
+    boolean distinct;
+    String offset;
+    String limit;
+    LimitingRowsStrategy limitingRowsStrategy = LimitingRowsStrategy.NOP;
+
+    public SQLStatement() {
+      // Prevent Synthetic Access
+      valuesList.add(new ArrayList<>());
+    }
+
+    private void sqlClause(SafeAppendable builder, String keyword, List<String> parts, String open, String close,
+        String conjunction) {
+      if (!parts.isEmpty()) {
+        if (!builder.isEmpty()) {
+          builder.append("\n");
+        }
+        builder.append(keyword);
+        builder.append(" ");
+        builder.append(open);
+        String last = "________";
+        for (int i = 0, n = parts.size(); i < n; i++) {
+          String part = parts.get(i);
+          if (i > 0 && !part.equals(AND) && !part.equals(OR) && !last.equals(AND) && !last.equals(OR)) {
+            builder.append(conjunction);
+          }
+          builder.append(part);
+          last = part;
+        }
+        builder.append(close);
+      }
+    }
+
+    private String selectSQL(SafeAppendable builder) {
+      if (distinct) {
+        sqlClause(builder, "SELECT DISTINCT", select, "", "", ", ");
+      } else {
+        sqlClause(builder, "SELECT", select, "", "", ", ");
+      }
+
+      sqlClause(builder, "FROM", tables, "", "", ", ");
+      joins(builder);
+      sqlClause(builder, "WHERE", where, "(", ")", " AND ");
+      sqlClause(builder, "GROUP BY", groupBy, "", "", ", ");
+      sqlClause(builder, "HAVING", having, "(", ")", " AND ");
+      sqlClause(builder, "ORDER BY", orderBy, "", "", ", ");
+      limitingRowsStrategy.appendClause(builder, offset, limit);
+      return builder.toString();
+    }
+
+    private void joins(SafeAppendable builder) {
+      sqlClause(builder, "JOIN", join, "", "", "\nJOIN ");
+      sqlClause(builder, "INNER JOIN", innerJoin, "", "", "\nINNER JOIN ");
+      sqlClause(builder, "OUTER JOIN", outerJoin, "", "", "\nOUTER JOIN ");
+      sqlClause(builder, "LEFT OUTER JOIN", leftOuterJoin, "", "", "\nLEFT OUTER JOIN ");
+      sqlClause(builder, "RIGHT OUTER JOIN", rightOuterJoin, "", "", "\nRIGHT OUTER JOIN ");
+    }
+
+    private String insertSQL(SafeAppendable builder) {
+      sqlClause(builder, "INSERT INTO", tables, "", "", "");
+      sqlClause(builder, "", columns, "(", ")", ", ");
+      for (int i = 0; i < valuesList.size(); i++) {
+        sqlClause(builder, i > 0 ? "," : "VALUES", valuesList.get(i), "(", ")", ", ");
+      }
+      return builder.toString();
+    }
+
+    private String deleteSQL(SafeAppendable builder) {
+      sqlClause(builder, "DELETE FROM", tables, "", "", "");
+      sqlClause(builder, "WHERE", where, "(", ")", " AND ");
+      limitingRowsStrategy.appendClause(builder, null, limit);
+      return builder.toString();
+    }
+
+    private String updateSQL(SafeAppendable builder) {
+      sqlClause(builder, "UPDATE", tables, "", "", "");
+      joins(builder);
+      sqlClause(builder, "SET", sets, "", "", ", ");
+      sqlClause(builder, "WHERE", where, "(", ")", " AND ");
+      limitingRowsStrategy.appendClause(builder, null, limit);
+      return builder.toString();
+    }
+
+    public String sql(Appendable a) {
+      SafeAppendable builder = new SafeAppendable(a);
+      if (statementType == null) {
+        return null;
+      }
+
+      String answer;
+
+      switch (statementType) {
+        case DELETE:
+          answer = deleteSQL(builder);
+          break;
+
+        case INSERT:
+          answer = insertSQL(builder);
+          break;
+
+        case SELECT:
+          answer = selectSQL(builder);
+          break;
+
+        case UPDATE:
+          answer = updateSQL(builder);
+          break;
+
+        default:
+          answer = null;
+      }
+
+      return answer;
+    }
+  }
+}

src/main/java/xyz/zhouxy/plusone/commons/exception/DbException.java

@@ -0,0 +1,19 @@
+package xyz.zhouxy.plusone.commons.exception;
+
+import com.google.common.annotations.Beta;
+
+@Beta
+public class DbException extends RuntimeException {
+
+    public DbException(String message) {
+        super(message);
+    }
+
+    public DbException(Throwable cause) {
+        super(cause);
+    }
+
+    public DbException(String message, Throwable cause) {
+        super(message, cause);
+    }
+}

src/main/java/xyz/zhouxy/plusone/commons/jdbc/JdbcUtil.java

@@ -0,0 +1,145 @@
+package xyz.zhouxy.plusone.commons.jdbc;
+
+import java.math.BigDecimal;
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.ResultSetMetaData;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.OptionalInt;
+import java.util.OptionalLong;
+
+import org.apache.commons.lang3.ArrayUtils;
+
+import com.google.common.annotations.Beta;
+
+import xyz.zhouxy.plusone.commons.util.DbRecord;
+import xyz.zhouxy.plusone.commons.util.MoreCollections;
+
+@Beta
+public class JdbcUtil {
+
+    public static JdbcExecutor connect(Connection conn) {
+        return new JdbcExecutor(conn);
+    }
+
+    private JdbcUtil() {
+        throw new IllegalStateException("Utility class");
+    }
+
+    public static class JdbcExecutor {
+
+        private final Connection conn;
+
+        public JdbcExecutor(Connection conn) {
+            this.conn = conn;
+        }
+
+        public <T> List<T> query(String sql, Object[] params, ResultMap<T> resultMap) throws SQLException {
+            try (PreparedStatement stmt = this.conn.prepareStatement(sql)) {
+                if (params != null && params.length > 0) {
+                    for (int i = 0; i < params.length; i++) {
+                        stmt.setObject(i + 1, params[i]);
+                    }
+                }
+                try (ResultSet rs = stmt.executeQuery()) {
+                    List<T> result = new ArrayList<>();
+                    while (rs.next()) {
+                        T e = resultMap.map(rs);
+                        result.add(e);
+                    }
+                    return result;
+                }
+            }
+        }
+
+        public static final ResultMap<Map<String, Object>> mapResultMap = rs -> {
+            Map<String, Object> result = new HashMap<>();
+            ResultSetMetaData metaData = rs.getMetaData();
+            int columnCount = metaData.getColumnCount();
+            for (int i = 1; i <= columnCount; i++) {
+                String colName = metaData.getColumnName(i);
+                result.put(colName, rs.getObject(colName));
+            }
+            return result;
+        };
+
+        public List<Map<String, Object>> query(String sql, Object... params) throws SQLException {
+            return query(sql, params, mapResultMap);
+        }
+
+        public static final ResultMap<DbRecord> recordResultMap = rs -> {
+            DbRecord result = new DbRecord();
+            ResultSetMetaData metaData = rs.getMetaData();
+            int columnCount = metaData.getColumnCount();
+            for (int i = 1; i <= columnCount; i++) {
+                String colName = metaData.getColumnName(i);
+                result.put(colName, rs.getObject(colName));
+            }
+            return result;
+        };
+
+        public List<DbRecord> queryToRecordList(String sql, Object... params) throws SQLException {
+            return query(sql, params, recordResultMap);
+        }
+
+        public Optional<String> queryToString(String sql, Object... params) throws SQLException {
+            List<String> result = query(sql, params, (ResultSet rs) -> rs.getString(1));
+            return MoreCollections.isNotEmpty(result) ? Optional.ofNullable(result.get(0)) : Optional.empty();
+        }
+
+        public OptionalInt queryToInt(String sql, Object... params) throws SQLException {
+            List<Integer> result = query(sql, params, (ResultSet rs) -> rs.getBigDecimal(1).intValue());
+            Integer i = MoreCollections.isNotEmpty(result) ? result.get(0) : null;
+            return i != null ? OptionalInt.of(i) : OptionalInt.empty();
+        }
+
+        public OptionalLong queryToLong(String sql, Object... params) throws SQLException {
+            List<Long> result = query(sql, params, (ResultSet rs) -> rs.getBigDecimal(1).longValue());
+            Long i = MoreCollections.isNotEmpty(result) ? result.get(0) : null;
+            return i != null ? OptionalLong.of(i) : OptionalLong.empty();
+        }
+
+        public Optional<BigDecimal> queryToBigDecimal(String sql, Object... params) throws SQLException {
+            List<BigDecimal> result = query(sql, params, (ResultSet rs) -> rs.getBigDecimal(1));
+            return MoreCollections.isNotEmpty(result) ? Optional.ofNullable(result.get(0)) : Optional.empty();
+        }
+
+        public int update(String sql, Object... params) throws SQLException {
+            try (PreparedStatement stmt = this.conn.prepareStatement(sql)) {
+                if (params != null && params.length > 0) {
+                    for (int i = 0; i < params.length; i++) {
+                        stmt.setObject(i + 1, params[i]);
+                    }
+                }
+                return stmt.executeUpdate();
+            }
+        }
+
+        public int[] batchUpdate(String sql, Collection<Object[]> params, int batchSize) throws SQLException {
+            int[] result = {};
+            try (PreparedStatement stmt = this.conn.prepareStatement(sql)) {
+                int i = 0;
+                for (Object[] ps : params) {
+                    i++;
+                    for (int j = 0; j < ps.length; j++) {
+                        stmt.setObject(j + 1, ps[j]);
+                    }
+                    stmt.addBatch();
+                    if (i % batchSize == 0 || i >= params.size()) {
+                        int[] n = stmt.executeBatch();
+                        result = ArrayUtils.addAll(result, n);
+                        stmt.clearBatch();
+                    }
+                }
+                return result;
+            }
+        }
+    }
+}

src/main/java/xyz/zhouxy/plusone/commons/jdbc/ResultMap.java

@@ -0,0 +1,12 @@
+package xyz.zhouxy.plusone.commons.jdbc;
+
+import java.sql.ResultSet;
+import java.sql.SQLException;
+
+import com.google.common.annotations.Beta;
+
+@Beta
+@FunctionalInterface
+public interface ResultMap<T> {
+    T map(ResultSet rs) throws SQLException;
+}

src/main/java/xyz/zhouxy/plusone/commons/jdbc/SQL.java

@@ -0,0 +1,25 @@
+package xyz.zhouxy.plusone.commons.jdbc;
+
+import org.apache.ibatis.jdbc.AbstractSQL;
+
+import com.google.common.annotations.Beta;
+
+/**
+ * @author ZhouXY
+ */
+@Beta
+public class SQL extends AbstractSQL<SQL> {
+
+    @Override
+    public SQL getSelf() {
+        return this;
+    }
+
+    public SQL WHERE_IF(boolean condition, String sqlConditions) {
+        if (condition) {
+            return WHERE(sqlConditions);
+        }
+        return getSelf();
+    }
+
+}

src/main/java/xyz/zhouxy/plusone/commons/util/DbRecord.java

@@ -0,0 +1,61 @@
+package xyz.zhouxy.plusone.commons.util;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.OptionalDouble;
+import java.util.OptionalInt;
+import java.util.OptionalLong;
+import java.util.Set;
+
+import com.google.common.annotations.Beta;
+
+@Beta
+public class DbRecord extends AbstractMapWrapper<String, Object, DbRecord> {
+
+    public DbRecord() {
+        super(new HashMap<>(), k -> Assert.isNotBlank(k, "Key can not be null."), null);
+    }
+
+    public DbRecord(Map<String, Object> map) {
+        super(map, k -> Assert.isNotBlank(k, "Key can not be null."), null);
+    }
+
+    public Optional<String> getValueAsString(String key) {
+        return this.<String>getAndConvert(key);
+    }
+
+    public <T> List<T> getValueAsList(String key) {
+        return this.<Collection<T>>getAndConvert(key)
+                .<List<T>>map(l -> (l instanceof List) ? (List<T>) l : new ArrayList<>(l))
+                .orElse(Collections.<T>emptyList());
+    }
+
+    public <T> Set<T> getValueAsSet(String key) {
+        return this.<Collection<T>>getAndConvert(key)
+                .<Set<T>>map(l -> (l instanceof Set) ? (Set<T>) l : new HashSet<>(l))
+                .orElse(Collections.<T>emptySet());
+    }
+
+    public OptionalInt getValueAsInt(String key) {
+        return OptionalUtil.toOptionalInt(this.<Integer>getAndConvert(key));
+    }
+
+    public OptionalLong getValueAsLong(String key) {
+        return OptionalUtil.toOptionalLong(this.<Long>getAndConvert(key));
+    }
+
+    public OptionalDouble getValueAsDouble(String key) {
+        return OptionalUtil.toOptionalDouble(this.<Double>getAndConvert(key));
+    }
+
+    @Override
+    protected DbRecord getSelf() {
+        return this;
+    }
+}

src/test/java/xyz/zhouxy/plusone/commons/util/JdbcUtilTests.java

@@ -0,0 +1,66 @@
+package xyz.zhouxy.plusone.commons.util;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
+
+import java.sql.Connection;
+import java.sql.SQLException;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+import javax.sql.DataSource;
+
+import org.junit.jupiter.api.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.zaxxer.hikari.HikariConfig;
+import com.zaxxer.hikari.HikariDataSource;
+
+import xyz.zhouxy.plusone.commons.jdbc.JdbcUtil;
+
+class JdbcUtilTests {
+
+    private static final Logger log = LoggerFactory.getLogger(JdbcUtilTests.class);
+
+    static final String url = "jdbc:postgresql://localhost:5432/plusone";
+    static final String username = "postgres";
+    static final String password = "zhouxy108";
+
+    DataSource dataSource;
+
+    String[] cStruct = {
+            "id",
+            "created_by",
+            "create_time",
+            "updated_by",
+            "update_time",
+            "status"
+    };
+
+    JdbcUtilTests() {
+        HikariConfig config = new HikariConfig();
+        config.setJdbcUrl(url);
+        config.setUsername(username);
+        config.setPassword(password);
+        this.dataSource = new HikariDataSource(config);
+    }
+
+    @Test
+    void testQuery() throws SQLException {
+        Connection conn = this.dataSource.getConnection();
+        List<Map<String, Object>> ms = JdbcUtil.connect(conn).query(
+                "SELECT * FROM public.base_table WHERE id IN (?, ?, ?)", 501533, 501554, 544599);
+        assertNotNull(ms);
+        List<DbRecord> es = ms.stream()
+                .map(input -> new DbRecord().putAll(input))
+                .collect(Collectors.toList());
+        assertEquals(3, es.size());
+        for (DbRecord baseEntity : es) {
+            log.info("id: {}", baseEntity.getValueAsLong("id"));
+            assertNull(baseEntity.getValueAsString("updated_by"));
+        }
+    }
+}