修改文件夹名与项目配置

api/pom.xml

@@ -0,0 +1,81 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xmlns="http://maven.apache.org/POM/4.0.0"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <parent>
+        <groupId>cc.carm.lib</groupId>
+        <artifactId>easysql-parent</artifactId>
+        <version>0.3.8</version>
+    </parent>
+    <modelVersion>4.0.0</modelVersion>
+
+    <properties>
+        <maven.compiler.source>11</maven.compiler.source>
+        <maven.compiler.target>11</maven.compiler.target>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+        <maven.compiler.encoding>UTF-8</maven.compiler.encoding>
+    </properties>
+
+    <artifactId>easysql-api</artifactId>
+    <packaging>jar</packaging>
+
+    <name>EasySQL-API</name>
+    <description>EasySQL的接口部分。用于打包到公共项目的API中，避免项目过大。</description>
+    <url>https://github.com/CarmJos/EasySQL</url>
+
+    <developers>
+        <developer>
+            <id>CarmJos</id>
+            <name>Carm Jos</name>
+            <email>carm@carm.cc</email>
+            <url>https://www.carm.cc</url>
+            <roles>
+                <role>Main Developer</role>
+            </roles>
+        </developer>
+    </developers>
+
+    <licenses>
+        <license>
+            <name>The MIT License</name>
+            <url>https://opensource.org/licenses/MIT</url>
+        </license>
+    </licenses>
+
+    <issueManagement>
+        <system>GitHub Issues</system>
+        <url>https://github.com/CarmJos/EasySQL/issues</url>
+    </issueManagement>
+
+    <ciManagement>
+        <system>GitHub Actions</system>
+        <url>https://github.com/CarmJos/EasySQL/actions/workflows/maven.yml</url>
+    </ciManagement>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-jar-plugin</artifactId>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-source-plugin</artifactId>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-javadoc-plugin</artifactId>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-shade-plugin</artifactId>
+            </plugin>
+        </plugins>
+    </build>
+
+
+</project>

api/src/main/java/cc/carm/lib/easysql/api/SQLAction.java

@@ -0,0 +1,212 @@
+package cc.carm.lib.easysql.api;
+
+import cc.carm.lib.easysql.api.function.SQLExceptionHandler;
+import cc.carm.lib.easysql.api.function.SQLFunction;
+import cc.carm.lib.easysql.api.function.SQLHandler;
+import cc.carm.lib.easysql.api.function.defaults.DefaultSQLExceptionHandler;
+import org.jetbrains.annotations.Contract;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.sql.SQLException;
+import java.util.UUID;
+import java.util.logging.Logger;
+
+/**
+ * SQLAction 是用于承载SQL语句并进行处理、返回的基本类。
+ *
+ * <ul>
+ *     <li>同步执行 {@link #execute()}, {@link #execute(SQLFunction, SQLExceptionHandler)}
+ *     <br>同步执行方法中有会抛出异常的方法与不抛出异常的方法，
+ *     <br>若选择不抛出异常，则返回值可能为空，需要特殊处理。</li>
+ *
+ *     <li>异步执行 {@link #executeAsync(SQLHandler, SQLExceptionHandler)}
+ *     <br>异步执行时将提供成功与异常两种处理方式
+ *     <br>可自行选择是否对数据或异常进行处理
+ *     <br>默认的异常处理器为 {@link #defaultExceptionHandler()}
+ *     <br>若有特殊需要，可通过{@link #setExceptionHandler(SQLExceptionHandler)} 方法修改默认的处理器</li>
+ * </ul>
+ *
+ * @param <T> 需要返回的类型
+ * @author CarmJos
+ * @since 0.0.1
+ */
+public interface SQLAction<T> {
+
+    /**
+     * 得到该Action的UUID
+     *
+     * @return UUID
+     */
+    @NotNull UUID getActionUUID();
+
+    /**
+     * 得到短八位格式的UUID
+     *
+     * @return UUID(8)
+     */
+    @NotNull String getShortID();
+
+    /**
+     * 得到该Action的创建时间
+     *
+     * @return 创建时间
+     */
+    long getCreateTime();
+
+    /**
+     * 得到该Action所要执行的源SQL语句
+     *
+     * @return 源SQL语句
+     */
+    @NotNull String getSQLContent();
+
+    /**
+     * 得到承载该Action的对应{@link SQLManager}
+     *
+     * @return {@link SQLManager}
+     */
+    @NotNull SQLManager getManager();
+
+    /**
+     * 执行该Action对应的SQL语句
+     *
+     * @return 指定数据类型
+     * @throws SQLException 当SQL操作出现问题时抛出
+     */
+    @NotNull T execute() throws SQLException;
+
+
+    /**
+     * 执行语句并返回值
+     *
+     * @param exceptionHandler 异常处理器 默认为 {@link #defaultExceptionHandler()}
+     * @return 指定类型数据
+     */
+    @Nullable
+    default T execute(@Nullable SQLExceptionHandler exceptionHandler) {
+        return execute(t -> t, exceptionHandler);
+    }
+
+    /**
+     * 执行语句并处理返回值
+     *
+     * @param function         处理方法
+     * @param exceptionHandler 异常处理器 默认为 {@link #defaultExceptionHandler()}
+     * @param <R>              需要返回的内容
+     * @return 指定类型数据
+     */
+    @Nullable
+    default <R> R execute(@NotNull SQLFunction<T, R> function,
+                          @Nullable SQLExceptionHandler exceptionHandler) {
+        return execute(function, null, exceptionHandler);
+    }
+
+    /**
+     * 执行语句并处理返回值
+     *
+     * @param function         处理方法
+     * @param defaultResult    默认结果，若处理后的结果为null，则返回该值
+     * @param exceptionHandler 异常处理器 默认为 {@link #defaultExceptionHandler()}
+     * @param <R>              需要返回的内容
+     * @return 指定类型数据
+     */
+    @Nullable
+    @Contract("_,!null,_ -> !null")
+    default <R> R execute(@NotNull SQLFunction<T, R> function,
+                          @Nullable R defaultResult,
+                          @Nullable SQLExceptionHandler exceptionHandler) {
+        try {
+            return executeFunction(function, defaultResult);
+        } catch (SQLException exception) {
+            handleException(exceptionHandler, exception);
+            return null;
+        }
+    }
+
+    /**
+     * 执行语句并处理返回值
+     *
+     * @param function 处理方法
+     * @param <R>      需要返回的内容
+     * @return 指定类型数据
+     * @throws SQLException 当SQL操作出现问题时抛出
+     */
+    @Nullable
+    default <R> R executeFunction(@NotNull SQLFunction<@NotNull T, R> function) throws SQLException {
+        return executeFunction(function, null);
+    }
+
+    /**
+     * 执行语句并处理返回值
+     *
+     * @param function      处理方法
+     * @param defaultResult 默认结果，若处理后的结果为null，则返回该值
+     * @param <R>           需要返回的内容
+     * @return 指定类型数据
+     * @throws SQLException 当SQL操作出现问题时抛出
+     */
+    @Nullable
+    @Contract("_,!null -> !null")
+    default <R> R executeFunction(@NotNull SQLFunction<@NotNull T, R> function,
+                                  @Nullable R defaultResult) throws SQLException {
+        try {
+            R result = function.apply(execute());
+            return result == null ? defaultResult : result;
+        } catch (SQLException exception) {
+            throw new SQLException(exception);
+        }
+    }
+
+    /**
+     * 异步执行SQL语句，采用默认异常处理，无需返回值。
+     */
+    default void executeAsync() {
+        executeAsync(null);
+    }
+
+    /**
+     * 异步执行SQL语句
+     *
+     * @param success 成功时的操作
+     */
+    default void executeAsync(@Nullable SQLHandler<T> success) {
+        executeAsync(success, null);
+    }
+
+    /**
+     * 异步执行SQL语句
+     *
+     * @param success 成功时的操作
+     * @param failure 异常处理器 默认为 {@link SQLAction#defaultExceptionHandler()}
+     */
+    void executeAsync(@Nullable SQLHandler<T> success,
+                      @Nullable SQLExceptionHandler failure);
+
+    default void handleException(@Nullable SQLExceptionHandler handler, SQLException exception) {
+        if (handler == null) handler = defaultExceptionHandler();
+        handler.accept(exception, this);
+    }
+
+    /**
+     * 默认的异常处理器
+     *
+     * @return {@link DefaultSQLExceptionHandler#get(Logger)}
+     * @see DefaultSQLExceptionHandler
+     */
+    default SQLExceptionHandler defaultExceptionHandler() {
+        return DefaultSQLExceptionHandler.get(getManager().getLogger());
+    }
+
+    /**
+     * 设定通用的异常处理器。
+     * <br> 在使用 {@link #execute(SQLExceptionHandler)} 等相关方法时，若传入的处理器为null，则会采用此处理器。
+     * <br> 若该方法传入参数为 null，则会使用 {@link #defaultExceptionHandler()} 。
+     *
+     * @param handler 异常处理器
+     */
+    default void setExceptionHandler(@Nullable SQLExceptionHandler handler) {
+        DefaultSQLExceptionHandler.setCustomHandler(handler);
+    }
+
+}

api/src/main/java/cc/carm/lib/easysql/api/SQLBuilder.java

@@ -0,0 +1,31 @@
+package cc.carm.lib.easysql.api;
+
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * SQLBuilder 是用于构建SQL语句以生成SQLAction执行操作的中间类。
+ * <br>其连接了{@link SQLManager} 与 {@link SQLAction} ,避免大量的代码堆积
+ * <br>也是本接口的核心功能所在
+ *
+ * @author CarmJos
+ */
+public interface SQLBuilder {
+
+    static @NotNull String withBackQuote(@NotNull String str) {
+        str = str.trim();
+        return !str.isEmpty() && str.charAt(0) == '`' && str.charAt(str.length() - 1) == '`' ? str : "`" + str + "`";
+    }
+
+    static @NotNull String withQuote(@NotNull String str) {
+        str = str.trim();
+        return !str.isEmpty() && str.charAt(0) == '\'' && str.charAt(str.length() - 1) == '\'' ? str : "'" + str + "'";
+    }
+
+    /**
+     * 得到承载该Builder的对应{@link SQLManager}
+     *
+     * @return {@link SQLManager}
+     */
+    @NotNull SQLManager getManager();
+
+}

api/src/main/java/cc/carm/lib/easysql/api/SQLManager.java

@@ -0,0 +1,180 @@
+package cc.carm.lib.easysql.api;
+
+import cc.carm.lib.easysql.api.action.PreparedSQLUpdateAction;
+import cc.carm.lib.easysql.api.action.PreparedSQLUpdateBatchAction;
+import cc.carm.lib.easysql.api.action.SQLUpdateAction;
+import cc.carm.lib.easysql.api.action.SQLUpdateBatchAction;
+import cc.carm.lib.easysql.api.builder.*;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import javax.sql.DataSource;
+import java.sql.Connection;
+import java.sql.SQLException;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+import java.util.function.Supplier;
+import java.util.logging.Logger;
+
+/**
+ * SQLManager 是EasySQL的核心类，用于管理数据库连接，提供数据库操作的方法。
+ *
+ * @author CarmJos
+ */
+public interface SQLManager {
+
+    Logger getLogger();
+
+    boolean isDebugMode();
+
+    void setDebugMode(@NotNull Supplier<@NotNull Boolean> debugMode);
+
+    default void setDebugMode(boolean enable) {
+        setDebugMode(() -> enable);
+    }
+
+    /**
+     * 得到连接池源
+     *
+     * @return DataSource
+     */
+    @NotNull DataSource getDataSource();
+
+    /**
+     * 得到一个数据库连接实例
+     *
+     * @return Connection
+     * @throws SQLException 见 {@link DataSource#getConnection()}
+     */
+    @NotNull Connection getConnection() throws SQLException;
+
+    /**
+     * 得到正使用的查询。
+     *
+     * @return 查询列表
+     */
+    @NotNull Map<UUID, SQLQuery> getActiveQuery();
+
+    /**
+     * 执行一条不需要返回结果的SQL语句(多用于UPDATE、REPLACE、DELETE方法)
+     * 该方法使用 Statement 实现，请注意SQL注入风险！
+     *
+     * @param sql SQL语句内容
+     * @return 更新的行数
+     * @see SQLUpdateAction
+     */
+    @Nullable Integer executeSQL(String sql);
+
+    /**
+     * 执行一条不需要返回结果的预处理SQL更改(UPDATE、REPLACE、DELETE)
+     *
+     * @param sql    SQL语句内容
+     * @param params SQL语句中 ? 的对应参数
+     * @return 更新的行数
+     * @see PreparedSQLUpdateAction
+     */
+    @Nullable Integer executeSQL(String sql, Object[] params);
+
+    /**
+     * 执行多条不需要返回结果的SQL更改(UPDATE、REPLACE、DELETE)
+     *
+     * @param sql         SQL语句内容
+     * @param paramsBatch SQL语句中对应?的参数组
+     * @return 对应参数返回的行数
+     * @see PreparedSQLUpdateBatchAction
+     */
+    @Nullable List<Integer> executeSQLBatch(String sql, Iterable<Object[]> paramsBatch);
+
+
+    /**
+     * 执行多条不需要返回结果的SQL。
+     * 该方法使用 Statement 实现，请注意SQL注入风险！
+     *
+     * @param sql     SQL语句内容
+     * @param moreSQL 更多SQL语句内容
+     * @return 对应参数返回的行数
+     * @see SQLUpdateBatchAction
+     */
+    @Nullable List<Integer> executeSQLBatch(@NotNull String sql, String... moreSQL);
+
+    /**
+     * 执行多条不需要返回结果的SQL。
+     *
+     * @param sqlBatch SQL语句内容
+     * @return 对应参数返回的行数
+     */
+    @Nullable List<Integer> executeSQLBatch(@NotNull Iterable<String> sqlBatch);
+
+    /**
+     * 在库中创建一个表
+     *
+     * @param tableName 表名
+     * @return {@link TableCreateBuilder}
+     */
+    TableCreateBuilder createTable(@NotNull String tableName);
+
+    /**
+     * 对库中的某个表执行更改
+     *
+     * @param tableName 表名
+     * @return {@link TableAlterBuilder}
+     */
+    TableAlterBuilder alterTable(@NotNull String tableName);
+
+    /**
+     * 新建一个查询
+     *
+     * @return {@link QueryBuilder}
+     */
+    QueryBuilder createQuery();
+
+    /**
+     * 创建一条插入操作
+     *
+     * @param tableName 目标表名
+     * @return {@link InsertBuilder}
+     */
+    InsertBuilder<PreparedSQLUpdateAction> createInsert(@NotNull String tableName);
+
+    /**
+     * 创建支持多组数据的插入操作
+     *
+     * @param tableName 目标表名
+     * @return {@link InsertBuilder}
+     */
+    InsertBuilder<PreparedSQLUpdateBatchAction> createInsertBatch(@NotNull String tableName);
+
+    /**
+     * 创建一条替换操作
+     *
+     * @param tableName 目标表名
+     * @return {@link ReplaceBuilder}
+     */
+    ReplaceBuilder<PreparedSQLUpdateAction> createReplace(@NotNull String tableName);
+
+    /**
+     * 创建支持多组数据的替换操作
+     *
+     * @param tableName 目标表名
+     * @return {@link ReplaceBuilder}
+     */
+    ReplaceBuilder<PreparedSQLUpdateBatchAction> createReplaceBatch(@NotNull String tableName);
+
+    /**
+     * 创建更新操作
+     *
+     * @param tableName 目标表名
+     * @return {@link UpdateBuilder}
+     */
+    UpdateBuilder createUpdate(@NotNull String tableName);
+
+    /**
+     * 创建删除操作
+     *
+     * @param tableName 目标表名
+     * @return {@link DeleteBuilder}
+     */
+    DeleteBuilder createDelete(@NotNull String tableName);
+
+}

api/src/main/java/cc/carm/lib/easysql/api/SQLQuery.java

@@ -0,0 +1,57 @@
+package cc.carm.lib.easysql.api;
+
+import cc.carm.lib.easysql.api.action.query.PreparedQueryAction;
+import cc.carm.lib.easysql.api.action.query.QueryAction;
+
+import java.sql.Connection;
+import java.sql.ResultSet;
+import java.sql.Statement;
+
+/**
+ * SQLQuery 是一个查询中间接口，用于查询操作的封装。
+ *
+ * @author CarmJos
+ */
+public interface SQLQuery extends AutoCloseable {
+
+    /**
+     * 获取该查询创建的时间
+     *
+     * @return 创建时间
+     */
+    long getExecuteTime();
+
+    /**
+     * 得到承载该SQLQuery的对应{@link SQLManager}
+     *
+     * @return {@link SQLManager}
+     */
+    SQLManager getManager();
+
+    /**
+     * 得到承载该SQLQuery的对应{@link QueryAction}
+     *
+     * @return {@link QueryAction} 或 {@link PreparedQueryAction}
+     */
+    QueryAction getAction();
+
+    ResultSet getResultSet();
+
+    /**
+     * 得到设定的SQL语句
+     *
+     * @return SQL语句
+     */
+    String getSQLContent();
+
+    /**
+     * 关闭所有内容
+     */
+    @Override
+    void close();
+
+    Statement getStatement();
+
+    Connection getConnection();
+
+}

api/src/main/java/cc/carm/lib/easysql/api/action/PreparedSQLUpdateAction.java

@@ -0,0 +1,23 @@
+package cc.carm.lib.easysql.api.action;
+
+import org.jetbrains.annotations.Nullable;
+
+public interface PreparedSQLUpdateAction extends SQLUpdateAction {
+
+    /**
+     * 设定SQL语句中所有 ? 对应的参数
+     *
+     * @param params 参数内容
+     * @return {@link PreparedSQLUpdateAction}
+     */
+    PreparedSQLUpdateAction setParams(Object... params);
+
+    /**
+     * 设定SQL语句中所有 ? 对应的参数
+     *
+     * @param params 参数内容
+     * @return {@link PreparedSQLUpdateAction}
+     */
+    PreparedSQLUpdateAction setParams(@Nullable Iterable<Object> params);
+
+}

api/src/main/java/cc/carm/lib/easysql/api/action/PreparedSQLUpdateBatchAction.java

@@ -0,0 +1,56 @@
+package cc.carm.lib.easysql.api.action;
+
+import cc.carm.lib.easysql.api.SQLAction;
+
+import java.util.List;
+
+public interface PreparedSQLUpdateBatchAction extends SQLAction<List<Integer>> {
+
+    /**
+     * 设定多组SQL语句中所有 ? 对应的参数
+     *
+     * @param allParams 所有参数内容
+     * @return {@link PreparedSQLUpdateBatchAction}
+     */
+    PreparedSQLUpdateBatchAction setAllParams(Iterable<Object[]> allParams);
+
+    /**
+     * 添加一组SQL语句中所有 ? 对应的参数
+     *
+     * @param params 参数内容
+     * @return {@link PreparedSQLUpdateBatchAction}
+     */
+    PreparedSQLUpdateBatchAction addParamsBatch(Object... params);
+
+    /**
+     * 设定自增主键的序列
+     *
+     * @param keyColumnIndex 自增主键的序列
+     *                       <br>若该值 ＞ 0，则 {@link #execute()} 返回自增主键数值
+     *                       <br>若该值 ≤ 0，则 {@link #execute()} 返回变更的行数
+     * @return {@link PreparedSQLUpdateBatchAction}
+     * @see #setReturnGeneratedKeys(boolean)
+     */
+    @Deprecated
+    default PreparedSQLUpdateBatchAction setKeyIndex(int keyColumnIndex) {
+        return setReturnGeneratedKeys(keyColumnIndex > 0);
+    }
+
+    /**
+     * 设定该操作返回自增键序列。
+     *
+     * @return {@link PreparedSQLUpdateBatchAction}
+     */
+    default PreparedSQLUpdateBatchAction returnGeneratedKeys() {
+        return setReturnGeneratedKeys(true);
+    }
+
+    /**
+     * 设定该操作是否返回自增键序列。
+     *
+     * @param returnGeneratedKey 是否返回自增键序列
+     * @return {@link PreparedSQLUpdateBatchAction}
+     */
+    PreparedSQLUpdateBatchAction setReturnGeneratedKeys(boolean returnGeneratedKey);
+
+}

api/src/main/java/cc/carm/lib/easysql/api/action/SQLUpdateAction.java

@@ -0,0 +1,38 @@
+package cc.carm.lib.easysql.api.action;
+
+import cc.carm.lib.easysql.api.SQLAction;
+
+public interface SQLUpdateAction extends SQLAction<Integer> {
+
+    /**
+     * 设定自增主键的序列
+     *
+     * @param keyColumnIndex 自增主键的序列
+     *                       <br>若该值 ＞ 0，则 {@link #execute()} 返回自增主键数值
+     *                       <br>若该值 ≤ 0，则 {@link #execute()} 返回变更的行数
+     * @return {@link SQLUpdateAction}
+     * @see #setReturnGeneratedKey(boolean)
+     */
+    @Deprecated
+    default SQLUpdateAction setKeyIndex(int keyColumnIndex) {
+        return setReturnGeneratedKey(keyColumnIndex > 0);
+    }
+
+    /**
+     * 设定该操作返回自增键序列。
+     *
+     * @return {@link SQLUpdateAction}
+     */
+    default SQLUpdateAction returnGeneratedKey() {
+        return setReturnGeneratedKey(true);
+    }
+
+    /**
+     * 设定该操作是否返回自增键序列。
+     *
+     * @param returnGeneratedKey 是否返回自增键序列
+     * @return {@link SQLUpdateAction}
+     */
+    SQLUpdateAction setReturnGeneratedKey(boolean returnGeneratedKey);
+
+}

api/src/main/java/cc/carm/lib/easysql/api/action/SQLUpdateBatchAction.java

@@ -0,0 +1,26 @@
+package cc.carm.lib.easysql.api.action;
+
+import cc.carm.lib.easysql.api.SQLAction;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.List;
+
+@SuppressWarnings("UnusedReturnValue")
+public interface SQLUpdateBatchAction extends SQLAction<List<Integer>> {
+
+    /**
+     * 添加一条批量执行的SQL语句
+     *
+     * @param sql SQL语句
+     * @return {@link SQLUpdateBatchAction}
+     */
+    SQLUpdateBatchAction addBatch(@NotNull String sql);
+
+    @Override
+    default @NotNull String getSQLContent() {
+        return getSQLContents().get(0);
+    }
+
+    List<String> getSQLContents();
+
+}

api/src/main/java/cc/carm/lib/easysql/api/action/query/PreparedQueryAction.java

@@ -0,0 +1,35 @@
+package cc.carm.lib.easysql.api.action.query;
+
+import org.jetbrains.annotations.Nullable;
+
+import java.sql.PreparedStatement;
+import java.util.function.Consumer;
+
+public interface PreparedQueryAction extends QueryAction {
+
+    /**
+     * 设定SQL语句中所有 ? 对应的参数
+     *
+     * @param params 参数内容
+     * @return {@link PreparedQueryAction}
+     */
+    PreparedQueryAction setParams(@Nullable Object... params);
+
+    /**
+     * 设定SQL语句中所有 ? 对应的参数
+     *
+     * @param params 参数内容
+     * @return {@link PreparedQueryAction}
+     */
+    PreparedQueryAction setParams(@Nullable Iterable<Object> params);
+
+    /**
+     * 直接对 {@link PreparedStatement} 进行处理
+     *
+     * @param statement {@link Consumer} 处理操作
+     *                  若为空则不进行处理
+     * @return {@link PreparedQueryAction}
+     */
+    PreparedQueryAction handleStatement(@Nullable Consumer<PreparedStatement> statement);
+
+}

api/src/main/java/cc/carm/lib/easysql/api/action/query/QueryAction.java

@@ -0,0 +1,47 @@
+package cc.carm.lib.easysql.api.action.query;
+
+import cc.carm.lib.easysql.api.SQLAction;
+import cc.carm.lib.easysql.api.SQLQuery;
+import cc.carm.lib.easysql.api.function.SQLExceptionHandler;
+import cc.carm.lib.easysql.api.function.SQLFunction;
+import cc.carm.lib.easysql.api.function.SQLHandler;
+import org.jetbrains.annotations.Contract;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.sql.SQLException;
+
+/**
+ * SQLQueryAction 是用于承载SQL查询语句并进行处理、返回并自动关闭连接的基本类。
+ *
+ * <ul>
+ *     <li>同步执行 {@link #execute()}, {@link #execute(SQLFunction, SQLExceptionHandler)}
+ *     <br>同步执行方法中有会抛出异常的方法与不抛出异常的方法，
+ *     <br>若选择不抛出异常，则返回值可能为空，需要特殊处理。</li>
+ *
+ *     <li>异步执行 {@link #executeAsync(SQLHandler, SQLExceptionHandler)}
+ *     <br>异步执行时将提供成功与异常两种处理方式
+ *     <br>可自行选择是否对数据或异常进行处理
+ *     <br>默认的异常处理器为 {@link #defaultExceptionHandler()}</li>
+ * </ul>
+ *
+ * <b>注意： 无论是否异步，都不需要自行关闭ResultSet，本API已自动关闭</b>
+ *
+ * @author CarmJos
+ * @since 0.2.6
+ */
+public interface QueryAction extends SQLAction<SQLQuery> {
+
+    @Override
+    @Contract("_,!null -> !null")
+    default <R> @Nullable R executeFunction(@NotNull SQLFunction<@NotNull SQLQuery, R> function,
+                                            @Nullable R defaultResult) throws SQLException {
+        try (SQLQuery value = execute()) {
+            R result = function.apply(value);
+            return result == null ? defaultResult : result;
+        } catch (SQLException exception) {
+            throw new SQLException(exception);
+        }
+    }
+
+}

api/src/main/java/cc/carm/lib/easysql/api/builder/ConditionalBuilder.java

@@ -0,0 +1,84 @@
+package cc.carm.lib.easysql.api.builder;
+
+import cc.carm.lib.easysql.api.SQLAction;
+import cc.carm.lib.easysql.api.SQLBuilder;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Date;
+import java.util.LinkedHashMap;
+
+public interface ConditionalBuilder<B extends ConditionalBuilder<B, T>, T extends SQLAction<?>> extends SQLBuilder {
+
+    /**
+     * 将现有条件构建完整的SQL语句用于执行。
+     *
+     * @return {@link SQLAction}
+     */
+    T build();
+
+    /**
+     * 设定限定的条目数
+     *
+     * @param limit 条数限制
+     * @return {@link B}
+     */
+    B setLimit(int limit);
+
+    /**
+     * 直接设定条件的源文本,不需要以WHERE开头。
+     * <br>如 {@code id = 1 AND name = 'test' OR name = 'test2'} 。
+     *
+     * @param condition 条件文本，不需要以WHERE开头。
+     * @return {@link B}
+     */
+    B setConditions(@Nullable String condition);
+
+    /**
+     * 直接设定每个条件的文本与其对应数值,将以AND链接，且不需要以WHERE开头。
+     * <br>条件如 {@code id = ? }，问号将被以对应的数值填充。。
+     *
+     * @param conditionSQLs 条件内容，将以AND链接，且不需要以WHERE开头。
+     * @return {@link B}
+     */
+    B setConditions(LinkedHashMap<@NotNull String, @Nullable Object> conditionSQLs);
+
+    B addCondition(@Nullable String condition);
+
+    B addCondition(@NotNull String columnName, @NotNull String operator, @Nullable Object queryValue);
+
+    default B addCondition(@NotNull String columnName, @Nullable Object queryValue) {
+        return addCondition(columnName, "=", queryValue);
+    }
+
+    B addCondition(@NotNull String[] columnNames, @Nullable Object[] queryValues);
+
+    B addNotNullCondition(@NotNull String columnName);
+
+    /**
+     * 添加时间的限定条件。 若设定了开始时间，则限定条件为 {@code endMillis >= startMillis}；
+     *
+     * @param columnName  判断的行
+     * @param startMillis 开始时间戳，若{@code <0}则不作限定
+     * @param endMillis   结束时间戳，若{@code <0}则不作限定
+     * @return {@link B}
+     */
+    default B addTimeCondition(@NotNull String columnName, long startMillis, long endMillis) {
+        return addTimeCondition(columnName,
+                startMillis > 0 ? new Date(startMillis) : null,
+                endMillis > 0 ? new Date(endMillis) : null
+        );
+    }
+
+    /**
+     * 添加时间的限定条件。 若设定了开始时间，则限定条件为 {@code endDate >= startTime}；
+     *
+     * @param columnName 判断的行
+     * @param startDate  开始时间，若为null则不作限定
+     * @param endDate    结束时间，若为null则不作限定
+     * @return {@link B}
+     */
+    B addTimeCondition(@NotNull String columnName, @Nullable java.util.Date startDate, @Nullable java.util.Date endDate);
+
+
+}

api/src/main/java/cc/carm/lib/easysql/api/builder/DeleteBuilder.java

@@ -0,0 +1,9 @@
+package cc.carm.lib.easysql.api.builder;
+
+import cc.carm.lib.easysql.api.SQLAction;
+
+public interface DeleteBuilder extends ConditionalBuilder<DeleteBuilder, SQLAction<Integer>> {
+
+    String getTableName();
+
+}

api/src/main/java/cc/carm/lib/easysql/api/builder/InsertBuilder.java

@@ -0,0 +1,19 @@
+package cc.carm.lib.easysql.api.builder;
+
+import cc.carm.lib.easysql.api.SQLAction;
+
+import java.util.Arrays;
+import java.util.List;
+
+public interface InsertBuilder<T extends SQLAction<?>> {
+
+    String getTableName();
+
+    T setColumnNames(List<String> columnNames);
+
+    default T setColumnNames(String... columnNames) {
+        return setColumnNames(columnNames == null ? null : Arrays.asList(columnNames));
+    }
+
+
+}

api/src/main/java/cc/carm/lib/easysql/api/builder/QueryBuilder.java

@@ -0,0 +1,37 @@
+package cc.carm.lib.easysql.api.builder;
+
+import cc.carm.lib.easysql.api.SQLBuilder;
+import cc.carm.lib.easysql.api.action.query.PreparedQueryAction;
+import cc.carm.lib.easysql.api.action.query.QueryAction;
+import org.jetbrains.annotations.NotNull;
+
+public interface QueryBuilder extends SQLBuilder {
+
+    /**
+     * 通过一条 SQL语句创建查询。
+     * 该方法使用 Statement 实现，请注意SQL注入风险！
+     *
+     * @param sql SQL语句
+     * @return {@link QueryAction}
+     * @deprecated 存在SQL注入风险，建议使用 {@link QueryBuilder#withPreparedSQL(String)}
+     */
+    @Deprecated
+    QueryAction withSQL(@NotNull String sql);
+
+    /**
+     * 通过一条 SQL语句创建预查询
+     *
+     * @param sql SQL语句
+     * @return {@link PreparedQueryAction}
+     */
+    PreparedQueryAction withPreparedSQL(@NotNull String sql);
+
+    /**
+     * 创建表查询
+     *
+     * @param tableName 表名
+     * @return {@link TableQueryBuilder}
+     */
+    TableQueryBuilder inTable(@NotNull String tableName);
+
+}

api/src/main/java/cc/carm/lib/easysql/api/builder/ReplaceBuilder.java

@@ -0,0 +1,25 @@
+package cc.carm.lib.easysql.api.builder;
+
+import cc.carm.lib.easysql.api.SQLAction;
+
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * REPLACE 语句用于将一组值更新进数据表中。
+ * <br> 执行后，将通过表中键判断该数据是否存在，若存在则用新数据替换原来的值，若不存在则会插入该数据。
+ * <br> 在使用REPLACE时，表与所给行列数据中必须包含唯一索引(或主键)，且索引不得为空值，否则将等同于插入语句。
+ *
+ * @param <T> 最终构建出的 {@link SQLAction} 类型
+ */
+public interface ReplaceBuilder<T extends SQLAction<?>> {
+
+    String getTableName();
+
+    T setColumnNames(List<String> columnNames);
+
+    default T setColumnNames(String... columnNames) {
+        return setColumnNames(columnNames == null ? null : Arrays.asList(columnNames));
+    }
+
+}

api/src/main/java/cc/carm/lib/easysql/api/builder/TableAlterBuilder.java

@@ -0,0 +1,129 @@
+package cc.carm.lib.easysql.api.builder;
+
+import cc.carm.lib.easysql.api.SQLAction;
+import cc.carm.lib.easysql.api.SQLBuilder;
+import cc.carm.lib.easysql.api.action.SQLUpdateAction;
+import cc.carm.lib.easysql.api.enums.IndexType;
+import cc.carm.lib.easysql.api.enums.NumberType;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+public interface TableAlterBuilder extends SQLBuilder {
+
+    SQLAction<Integer> renameTo(@NotNull String newTableName);
+
+    SQLAction<Integer> changeComment(@NotNull String newTableComment);
+
+    SQLAction<Integer> setAutoIncrementIndex(int index);
+
+    SQLAction<Integer> addIndex(@NotNull IndexType indexType, @Nullable String indexName,
+                                @NotNull String columnName, @NotNull String... moreColumns);
+
+    /**
+     * 为该表移除一个索引
+     *
+     * @param indexName 索引名
+     * @return {@link SQLUpdateAction}
+     */
+    SQLAction<Integer> dropIndex(@NotNull String indexName);
+
+    /**
+     * 为该表移除一个外键
+     *
+     * @param keySymbol 外键名
+     * @return {@link SQLUpdateAction}
+     */
+    SQLAction<Integer> dropForeignKey(@NotNull String keySymbol);
+
+    /**
+     * 为该表移除主键(须添加新主键)
+     *
+     * @return {@link SQLUpdateAction}
+     */
+    SQLAction<Integer> dropPrimaryKey();
+
+    /**
+     * 为表添加一列
+     *
+     * @param columnName 列名
+     * @param settings   列的相关设定
+     * @return {@link SQLUpdateAction}
+     */
+    default SQLAction<Integer> addColumn(@NotNull String columnName, @NotNull String settings) {
+        return addColumn(columnName, settings, null);
+    }
+
+    /**
+     * 为表添加一列
+     *
+     * @param columnName  列名
+     * @param settings    列的相关设定
+     * @param afterColumn 该列增添到哪个列的后面，
+     *                    <p> 该参数若省缺则放于最后一行
+     *                    <p> 若为 "" 则置于首行。
+     * @return {@link SQLUpdateAction}
+     */
+    SQLAction<Integer> addColumn(@NotNull String columnName, @NotNull String settings, @Nullable String afterColumn);
+
+    SQLAction<Integer> renameColumn(@NotNull String columnName, @NotNull String newName);
+
+    SQLAction<Integer> modifyColumn(@NotNull String columnName, @NotNull String settings);
+
+    default SQLAction<Integer> modifyColumn(@NotNull String columnName, @NotNull String columnSettings, @NotNull String afterColumn) {
+        return modifyColumn(columnName, columnSettings + " AFTER `" + afterColumn + "`");
+    }
+
+    SQLAction<Integer> removeColumn(@NotNull String columnName);
+
+    SQLAction<Integer> setColumnDefault(@NotNull String columnName, @NotNull String defaultValue);
+
+    SQLAction<Integer> removeColumnDefault(@NotNull String columnName);
+
+    /**
+     * 为该表添加一个自增列
+     * <p> 自增列强制要求为数字类型，非空，且为UNIQUE。
+     * <p> 注意：一个表只允许有一个自增列！
+     *
+     * @param columnName 列名
+     * @param numberType 数字类型，若省缺则为 {@link NumberType#INT}
+     * @param primary    是否为主键，若否则只为唯一键
+     * @param unsigned   是否采用 UNSIGNED (即无负数，可以增加自增键的最高数，建议为true)
+     * @return {@link TableCreateBuilder}
+     */
+    default SQLAction<Integer> addAutoIncrementColumn(@NotNull String columnName, @Nullable NumberType numberType,
+                                                      boolean primary, boolean unsigned) {
+        return addColumn(columnName,
+                (numberType == null ? NumberType.INT : numberType).name()
+                        + (unsigned ? " UNSIGNED " : " ")
+                        + "NOT NULL AUTO_INCREMENT " + (primary ? "PRIMARY KEY" : "UNIQUE KEY"),
+                ""
+        );
+    }
+
+    /**
+     * 为该表添加一个自增列
+     * <br> 自增列强制要求为数字类型，非空，且为UNIQUE。
+     * <p> 注意：一个表只允许有一个自增列！
+     *
+     * @param columnName 列名
+     * @param numberType 数字类型，若省缺则为 {@link NumberType#INT}
+     * @return {@link TableAlterBuilder}
+     */
+    default SQLAction<Integer> addAutoIncrementColumn(@NotNull String columnName, @NotNull NumberType numberType) {
+        return addAutoIncrementColumn(columnName, numberType, false, true);
+    }
+
+
+    /**
+     * 为该表添加一个自增列
+     * <br> 自增列强制要求为数字类型，非空，且为UNIQUE。
+     * <p> 注意：一个表只允许有一个自增列！
+     *
+     * @param columnName 列名
+     * @return {@link TableAlterBuilder}
+     */
+    default SQLAction<Integer> addAutoIncrementColumn(@NotNull String columnName) {
+        return addAutoIncrementColumn(columnName, NumberType.INT);
+    }
+
+}

api/src/main/java/cc/carm/lib/easysql/api/builder/TableCreateBuilder.java

@@ -0,0 +1,256 @@
+package cc.carm.lib.easysql.api.builder;
+
+import cc.carm.lib.easysql.api.SQLBuilder;
+import cc.carm.lib.easysql.api.action.SQLUpdateAction;
+import cc.carm.lib.easysql.api.enums.ForeignKeyRule;
+import cc.carm.lib.easysql.api.enums.IndexType;
+import cc.carm.lib.easysql.api.enums.NumberType;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Objects;
+
+import static cc.carm.lib.easysql.api.SQLBuilder.withBackQuote;
+import static cc.carm.lib.easysql.api.SQLBuilder.withQuote;
+
+
+public interface TableCreateBuilder extends SQLBuilder {
+
+    /**
+     * 将现有条件构建完整的SQL语句用于执行。
+     *
+     * @return {@link SQLUpdateAction}
+     */
+    SQLUpdateAction build();
+
+    @NotNull String getTableName();
+
+    /**
+     * 得到表的设定。
+     * <p> 若未使用 {@link #setTableSettings(String)} 方法则会采用 {@link #defaultTablesSettings()} 。
+     *
+     * @return TableSettings
+     */
+    @NotNull String getTableSettings();
+
+    TableCreateBuilder setTableSettings(@NotNull String settings);
+
+    /**
+     * 设定表的标注，一般用于解释该表的作用。
+     *
+     * @param comment 表标注
+     * @return {@link TableCreateBuilder}
+     */
+    TableCreateBuilder setTableComment(@Nullable String comment);
+
+    /**
+     * 直接设定表的所有列信息
+     *
+     * @param columns 列的相关信息 (包括列设定)
+     * @return {@link TableCreateBuilder}
+     */
+    TableCreateBuilder setColumns(@NotNull String... columns);
+
+    /**
+     * 为该表添加一个列
+     *
+     * @param column 列的相关信息
+     *               <br>如 `uuid` VARCHAR(36) NOT NULL UNIQUE KEY
+     * @return {@link TableCreateBuilder}
+     */
+    TableCreateBuilder addColumn(@NotNull String column);
+
+    /**
+     * 为该表添加一个列
+     *
+     * @param columnName 列名
+     * @param settings   列的设定
+     *                   <br>如 VARCHAR(36) NOT NULL UNIQUE KEY
+     * @return {@link TableCreateBuilder}
+     */
+    default TableCreateBuilder addColumn(@NotNull String columnName, @NotNull String settings) {
+        Objects.requireNonNull(columnName, "columnName could not be null");
+        return addColumn(withBackQuote(columnName) + " " + settings);
+    }
+
+    /**
+     * 为该表添加一个列
+     *
+     * @param columnName 列名
+     * @param settings   列的设定
+     *                   <br>如 VARCHAR(36) NOT NULL UNIQUE KEY
+     * @param comments   列的注解，用于解释该列数据的作用
+     * @return {@link TableCreateBuilder}
+     */
+    default TableCreateBuilder addColumn(@NotNull String columnName, @NotNull String settings, @NotNull String comments) {
+        return addColumn(columnName, settings + " COMMENT " + withQuote(comments));
+    }
+
+    /**
+     * 为该表添加一个自增列
+     * <p> 自增列强制要求为数字类型，非空，且为UNIQUE。
+     * <p> 注意：一个表只允许有一个自增列！
+     *
+     * @param columnName   列名
+     * @param numberType   数字类型，若省缺则为 {@link NumberType#INT}
+     * @param asPrimaryKey 是否为主键，若为false则设定为唯一键
+     * @param unsigned     是否采用 UNSIGNED (即无负数，可以增加自增键的最高数，建议为true)
+     * @return {@link TableCreateBuilder}
+     */
+    TableCreateBuilder addAutoIncrementColumn(@NotNull String columnName, @Nullable NumberType numberType,
+                                              boolean asPrimaryKey, boolean unsigned);
+
+    /**
+     * 为该表添加一个INT类型的自增主键列
+     * <p> 自增列强制要求为数字类型，非空，且为UNIQUE。
+     * <p> 注意：一个表只允许有一个自增列！
+     *
+     * @param columnName   列名
+     * @param asPrimaryKey 是否为主键，若为false则设定为唯一键
+     * @param unsigned     是否采用 UNSIGNED (即无负数，可以增加自增键的最高数，建议为true)
+     * @return {@link TableCreateBuilder}
+     */
+    default TableCreateBuilder addAutoIncrementColumn(@NotNull String columnName,
+                                                      boolean asPrimaryKey, boolean unsigned) {
+        return addAutoIncrementColumn(columnName, NumberType.INT, asPrimaryKey, unsigned);
+    }
+
+
+    /**
+     * 为该表添加一个INT类型的自增列
+     * <p> 自增列强制要求为数字类型，非空，且为UNIQUE。
+     * <p> 注意：一个表只允许有一个自增列！
+     *
+     * @param columnName   列名
+     * @param asPrimaryKey 是否为主键，若为false则设定为唯一键
+     * @return {@link TableCreateBuilder}
+     */
+    default TableCreateBuilder addAutoIncrementColumn(@NotNull String columnName, boolean asPrimaryKey) {
+        return addAutoIncrementColumn(columnName, asPrimaryKey, true);
+    }
+
+    /**
+     * 为该表添加一个INT类型的自增主键列
+     * <p> 自增列强制要求为数字类型，非空，且为UNIQUE。
+     * <p> 注意：一个表只允许有一个自增列！
+     *
+     * @param columnName 列名
+     * @return {@link TableCreateBuilder}
+     */
+    default TableCreateBuilder addAutoIncrementColumn(@NotNull String columnName) {
+        return addAutoIncrementColumn(columnName, true);
+    }
+
+    /**
+     * 设定表中的某列为索引或键。
+     *
+     * <p>创建索引时，你需要确保该索引是应用在 SQL 查询语句的条件(一般作为 WHERE 子句的条件)。
+     * <br>虽然索引大大提高了查询速度，同时却会降低更新表的速度，如对表进行INSERT、UPDATE 和DELETE。
+     * <br>因此，请合理的设计索引。
+     *
+     * @param type       索引类型
+     * @param columnName 索引包含的列
+     * @return {@link TableCreateBuilder}
+     */
+    default TableCreateBuilder setIndex(@NotNull String columnName,
+                                        @NotNull IndexType type) {
+        return setIndex(type, null, columnName);
+    }
+
+    /**
+     * 设定表中的某列为索引或键。
+     *
+     * <p>创建索引时，你需要确保该索引是应用在 SQL 查询语句的条件(一般作为 WHERE 子句的条件)。
+     * <br>虽然索引大大提高了查询速度，同时却会降低更新表的速度，如对表进行INSERT、UPDATE 和DELETE。
+     * <br>因此，请合理的设计索引。
+     *
+     * @param type        索引类型
+     * @param indexName   索引名称，缺省时将根据第一个索引列赋一个名称
+     * @param columnName  索引包含的列
+     * @param moreColumns 联合索引需要包含的列
+     * @return {@link TableCreateBuilder}
+     */
+    TableCreateBuilder setIndex(@NotNull IndexType type, @Nullable String indexName,
+                                @NotNull String columnName, @NotNull String... moreColumns);
+
+
+    /**
+     * 以本表位从表，为表中某列设定自参照外键(即自参照完整性)。
+     *
+     * <p>外键约束（FOREIGN KEY）是表的一个特殊字段，经常与主键约束一起使用。
+     * <br>外键用来建立主表与从表的关联关系，为两个表的数据建立连接，约束两个表中数据的一致性和完整性。
+     * <br>主表删除某条记录时，从表中与之对应的记录也必须有相应的改变。
+     *
+     * @param tableColumn   本表中的列
+     * @param foreignColumn 外键关联表中对应的关联列，必须为目标表的主键，即 {@link IndexType#PRIMARY_KEY}
+     * @return {@link TableCreateBuilder}
+     */
+    default TableCreateBuilder addForeignKey(@NotNull String tableColumn, @NotNull String foreignColumn) {
+        return addForeignKey(tableColumn, getTableName(), foreignColumn);
+    }
+
+    /**
+     * 以本表位从表，为表中某列设定外键。
+     *
+     * <p>外键约束（FOREIGN KEY）是表的一个特殊字段，经常与主键约束一起使用。
+     * <br>外键用来建立主表与从表的关联关系，为两个表的数据建立连接，约束两个表中数据的一致性和完整性。
+     * <br>主表删除某条记录时，从表中与之对应的记录也必须有相应的改变。
+     *
+     * @param tableColumn   本表中的列
+     * @param foreignTable  外键关联主表，必须为已存在的表或本表，且必须有主键。
+     * @param foreignColumn 外键关联主表中对应的关联列，须满足
+     *                      <p> 1. 为主表的主键，即 {@link IndexType#PRIMARY_KEY}
+     *                      <p> 2. 数据类型必须和所要建立主键的列的数据类型相同。
+     * @return {@link TableCreateBuilder}
+     */
+    default TableCreateBuilder addForeignKey(@NotNull String tableColumn,
+                                             @NotNull String foreignTable, @NotNull String foreignColumn) {
+        return addForeignKey(tableColumn, null, foreignTable, foreignColumn);
+    }
+
+    /**
+     * 以本表位从表，为表中某列设定外键。
+     *
+     * <p>外键约束（FOREIGN KEY）是表的一个特殊字段，经常与主键约束一起使用。
+     * <br>外键用来建立主表与从表的关联关系，为两个表的数据建立连接，约束两个表中数据的一致性和完整性。
+     * <br>主表删除某条记录时，从表中与之对应的记录也必须有相应的改变。
+     *
+     * @param tableColumn    本表中的列
+     * @param constraintName 约束名，缺省时将使用参数自动生成，如 <i>fk_[tableColumn]_[foreignTable]</i>
+     * @param foreignTable   外键关联主表，必须为已存在的表或本表，且必须有主键。
+     * @param foreignColumn  外键关联主表中对应的关联列，须满足
+     *                       <p> 1. 为主表的主键，即 {@link IndexType#PRIMARY_KEY}
+     *                       <p> 2. 数据类型必须和所要建立主键的列的数据类型相同。
+     * @return {@link TableCreateBuilder}
+     */
+    default TableCreateBuilder addForeignKey(@NotNull String tableColumn, @Nullable String constraintName,
+                                             @NotNull String foreignTable, @NotNull String foreignColumn) {
+        return addForeignKey(tableColumn, constraintName, foreignTable, foreignColumn, null, null);
+    }
+
+    /**
+     * 以本表位从表，为表中某列设定外键。
+     *
+     * <p>外键约束（FOREIGN KEY）是表的一个特殊字段，经常与主键约束一起使用。
+     * <br>外键用来建立主表与从表的关联关系，为两个表的数据建立连接，约束两个表中数据的一致性和完整性。
+     * <br>主表删除某条记录时，从表中与之对应的记录也必须有相应的改变。
+     *
+     * @param tableColumn    本表中的列
+     * @param constraintName 约束名，缺省时将使用参数自动生成，如 <i>fk_[tableColumn]_[foreignTable]</i>
+     * @param foreignTable   外键关联主表，必须为已存在的表或本表，且必须有主键。
+     * @param foreignColumn  外键关联主表中对应的关联列，须满足
+     *                       <p> 1. 为主表的主键，即 {@link IndexType#PRIMARY_KEY}
+     *                       <p> 2. 数据类型必须和所要建立主键的列的数据类型相同。
+     * @param updateRule     在外键被更新时采用的规则，缺省时默认为{@link ForeignKeyRule#RESTRICT}
+     * @param deleteRule     在外键被删除时采用的规则，缺省时默认为{@link ForeignKeyRule#RESTRICT}
+     * @return {@link TableCreateBuilder}
+     */
+    TableCreateBuilder addForeignKey(@NotNull String tableColumn, @Nullable String constraintName,
+                                     @NotNull String foreignTable, @NotNull String foreignColumn,
+                                     @Nullable ForeignKeyRule updateRule, @Nullable ForeignKeyRule deleteRule);
+
+    default String defaultTablesSettings() {
+        return "ENGINE=InnoDB DEFAULT CHARSET=utf8";
+    }
+
+}

api/src/main/java/cc/carm/lib/easysql/api/builder/TableQueryBuilder.java

@@ -0,0 +1,37 @@
+package cc.carm.lib.easysql.api.builder;
+
+import cc.carm.lib.easysql.api.action.query.PreparedQueryAction;
+import org.jetbrains.annotations.NotNull;
+
+public interface TableQueryBuilder extends ConditionalBuilder<TableQueryBuilder, PreparedQueryAction> {
+
+    @NotNull String getTableName();
+
+    /**
+     * 选定用于查询的列名
+     *
+     * @param columnNames 列名
+     * @return {@link TableQueryBuilder}
+     */
+    TableQueryBuilder selectColumns(@NotNull String... columnNames);
+
+    /**
+     * 对结果进行排序
+     *
+     * @param columnName 排序使用的列名
+     * @param asc        是否为正序排序 (为false则倒序排序)
+     * @return {@link TableQueryBuilder}
+     */
+    TableQueryBuilder orderBy(@NotNull String columnName, boolean asc);
+
+    /**
+     * 限制查询条数，用于分页查询。
+     *
+     * @param start 开始数
+     * @param end   结束条数
+     * @return {@link TableQueryBuilder}
+     * @since 0.2.6
+     */
+    TableQueryBuilder setPageLimit(int start, int end);
+
+}

api/src/main/java/cc/carm/lib/easysql/api/builder/UpdateBuilder.java

@@ -0,0 +1,56 @@
+package cc.carm.lib.easysql.api.builder;
+
+import cc.carm.lib.easysql.api.SQLAction;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.LinkedHashMap;
+
+public interface UpdateBuilder extends ConditionalBuilder<UpdateBuilder, SQLAction<Integer>> {
+
+    String getTableName();
+
+    /**
+     * 添加一条需要更新的字段名与值
+     *
+     * @param columnName  字段名
+     * @param columnValue 字段名对应的值
+     * @return {@link UpdateBuilder}
+     * @since 0.3.7
+     */
+    UpdateBuilder addColumnValue(@NotNull String columnName, @Nullable Object columnValue);
+
+    /**
+     * 设定更新的全部字段值 <b>(此操作会覆盖之前的设定)</b>
+     * <p> <b>此操作会覆盖之前的设定</b>
+     *
+     * @param columnData 字段名和值的键值对
+     * @return {@link UpdateBuilder}
+     */
+    UpdateBuilder setColumnValues(LinkedHashMap<@NotNull String, @Nullable Object> columnData);
+
+    /**
+     * 设定更新的全部字段值 <b>(此操作会覆盖之前的设定)</b>
+     * <p> <b>此操作会覆盖之前的设定</b>
+     *
+     * @param columnNames  字段名
+     * @param columnValues 字段名对应的值
+     * @return {@link UpdateBuilder}
+     */
+    UpdateBuilder setColumnValues(@NotNull String[] columnNames, @Nullable Object[] columnValues);
+
+    /**
+     * 设定更新的全部字段值 <b>(此操作会覆盖之前的设定)</b>
+     * <p> 如需同时更新多条字段，请使用 {@link #setColumnValues(String[], Object[])} 或 {@link #setColumnValues(LinkedHashMap)}
+     * <br>也可以使用 {@link #addColumnValue(String, Object)} 一条条的添加字段
+     *
+     * @param columnName  字段名
+     * @param columnValue 字段名对应的值
+     * @return {@link UpdateBuilder}
+     */
+    default UpdateBuilder setColumnValues(@NotNull String columnName, @Nullable Object columnValue) {
+        return setColumnValues(new String[]{columnName}, new Object[]{columnValue});
+    }
+
+
+}

api/src/main/java/cc/carm/lib/easysql/api/builder/UpsertBuilder.java

@@ -0,0 +1,17 @@
+package cc.carm.lib.easysql.api.builder;
+
+/**
+ * 存在则更新，不存在则插入。
+ *
+ * @see ReplaceBuilder
+ */
+@Deprecated
+public interface UpsertBuilder {
+
+    String getTableName();
+
+    default UpsertBuilder setColumnNames(String[] columnNames, String updateColumn) {
+        throw new UnsupportedOperationException("Please use REPLACE .");
+    }
+
+}

api/src/main/java/cc/carm/lib/easysql/api/enums/ForeignKeyRule.java

@@ -0,0 +1,41 @@
+package cc.carm.lib.easysql.api.enums;
+
+public enum ForeignKeyRule {
+
+    /**
+     * 啥也不做
+     * <p>注意： 在Mysql中该选项实际上等同于采用默认的 {@link #RESTRICT} 设定！
+     */
+    NO_ACTION("NO ACTION"),
+
+    /**
+     * 拒绝删除要求，直到使用删除键值的辅助表被手工删除，并且没有参照时(这是默认设置，也是最安全的设置)
+     */
+    RESTRICT("RESTRICT"),
+
+    /**
+     * 修改包含与已删除键值有参照关系的所有记录，使用NULL值替换（只能用于已标记为NOT NULL的字段）
+     */
+    SET_NULL("SET NULL"),
+
+    /**
+     * 修改包含与已删除键值有参照关系的所有记录，使用默认值替换（只能用于设定了DEFAULT的字段）
+     */
+    SET_DEFAULT("SET DEFAULT"),
+
+    /**
+     * <b>级联删除</b>，删除包含与已删除键值有参照关系的所有记录
+     */
+    CASCADE("CASCADE");
+
+    final String ruleName;
+
+    ForeignKeyRule(String ruleName) {
+        this.ruleName = ruleName;
+    }
+
+    public String getRuleName() {
+        return ruleName;
+    }
+
+}

api/src/main/java/cc/carm/lib/easysql/api/enums/IndexType.java

@@ -0,0 +1,41 @@
+package cc.carm.lib.easysql.api.enums;
+
+public enum IndexType {
+
+
+    /**
+     * <b>普通索引</b>（由关键字KEY或INDEX定义的索引）的唯一任务是加快对数据的访问速度。
+     * <br> 因此，应该只为那些最经常出现在查询条件（WHERE column=）或排序条件（ORDER BY column）中的数据列创建索引。
+     * <br> 只要有可能，就应该选择一个数据最整齐、最紧凑的数据列（如一个整数类型的数据列）来创建索引。
+     */
+    INDEX("INDEX"),
+
+
+    /**
+     * <b>唯一索引</b> 是在表上一个或者多个字段组合建立的索引，这个或者这些字段的值组合起来在表中不可以重复，用于保证数据的唯一性。
+     */
+    UNIQUE_KEY("UNIQUE KEY"),
+
+    /**
+     * <b>主键索引</b> 是唯一索引的特定类型。表中创建主键时自动创建的索引 。一个表只能建立一个主索引。
+     */
+    PRIMARY_KEY("PRIMARY KEY"),
+
+    /**
+     * <b>全文索引</b> 主要用来查找文本中的关键字，而不是直接与索引中的值相比较。
+     * <br> 请搭配 MATCH 等语句使用，而不是使用 WHERE - LIKE 。
+     * <br> 全文索引只可用于 CHAR、 VARCHAR 与 TEXT 系列类型。
+     */
+    FULLTEXT_INDEX("FULLTEXT");
+
+
+    final String name;
+
+    IndexType(String name) {
+        this.name = name;
+    }
+
+    public String getName() {
+        return name;
+    }
+}

api/src/main/java/cc/carm/lib/easysql/api/enums/NumberType.java

@@ -0,0 +1,11 @@
+package cc.carm.lib.easysql.api.enums;
+
+public enum NumberType {
+
+    TINYINT,
+    SMALLINT,
+    MEDIUMINT,
+    INT,
+    BIGINT
+
+}

api/src/main/java/cc/carm/lib/easysql/api/function/SQLExceptionHandler.java

@@ -0,0 +1,12 @@
+package cc.carm.lib.easysql.api.function;
+
+import cc.carm.lib.easysql.api.SQLAction;
+
+import java.sql.SQLException;
+import java.util.function.BiConsumer;
+
+@FunctionalInterface
+public interface SQLExceptionHandler extends BiConsumer<SQLException, SQLAction<?>> {
+
+
+}

api/src/main/java/cc/carm/lib/easysql/api/function/SQLFunction.java

@@ -0,0 +1,14 @@
+package cc.carm.lib.easysql.api.function;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.sql.SQLException;
+
+@FunctionalInterface
+public interface SQLFunction<T, R> {
+
+    @Nullable
+    R apply(@NotNull T t) throws SQLException;
+
+}

api/src/main/java/cc/carm/lib/easysql/api/function/SQLHandler.java

@@ -0,0 +1,23 @@
+package cc.carm.lib.easysql.api.function;
+
+import org.jetbrains.annotations.Contract;
+import org.jetbrains.annotations.NotNull;
+
+import java.sql.SQLException;
+import java.util.Objects;
+
+@FunctionalInterface
+public interface SQLHandler<T> {
+
+    void accept(@NotNull T t) throws SQLException;
+
+    @NotNull
+    @Contract(pure = true)
+    default SQLHandler<T> andThen(@NotNull SQLHandler<? super T> after) {
+        Objects.requireNonNull(after);
+        return (T t) -> {
+            accept(t);
+            after.accept(t);
+        };
+    }
+}

api/src/main/java/cc/carm/lib/easysql/api/function/defaults/DefaultSQLExceptionHandler.java

@@ -0,0 +1,56 @@
+package cc.carm.lib.easysql.api.function.defaults;
+
+import cc.carm.lib.easysql.api.SQLAction;
+import cc.carm.lib.easysql.api.action.SQLUpdateBatchAction;
+import cc.carm.lib.easysql.api.function.SQLExceptionHandler;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.sql.SQLException;
+import java.util.logging.Logger;
+
+public class DefaultSQLExceptionHandler implements SQLExceptionHandler {
+
+    private static @Nullable SQLExceptionHandler customDefaultHandler = null;
+    private final Logger logger;
+
+    public DefaultSQLExceptionHandler(Logger logger) {
+        this.logger = logger;
+    }
+
+    public static @Nullable SQLExceptionHandler getCustomHandler() {
+        return customDefaultHandler;
+    }
+
+    public static void setCustomHandler(@Nullable SQLExceptionHandler handler) {
+        DefaultSQLExceptionHandler.customDefaultHandler = handler;
+    }
+
+    public static @NotNull SQLExceptionHandler get(Logger logger) {
+        if (getCustomHandler() != null) return getCustomHandler();
+        else return new DefaultSQLExceptionHandler(logger);
+    }
+
+    protected Logger getLogger() {
+        return logger;
+    }
+
+    @Override
+    public void accept(SQLException exception, SQLAction<?> sqlAction) {
+        if (sqlAction instanceof SQLUpdateBatchAction) {
+
+            getLogger().severe("Error when execute SQLs : ");
+            int i = 1;
+            for (String content : ((SQLUpdateBatchAction) sqlAction).getSQLContents()) {
+                getLogger().severe(String.format("#%d {%s}", i, content));
+                i++;
+            }
+
+        } else {
+            getLogger().severe("Error when execute { " + sqlAction.getSQLContent() + " }");
+        }
+        exception.printStackTrace();
+    }
+
+
+}

api/src/main/java/cc/carm/lib/easysql/api/util/TimeDateUtils.java

@@ -0,0 +1,108 @@
+package cc.carm.lib.easysql.api.util;
+
+import java.text.DateFormat;
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+
+public class TimeDateUtils {
+    public static final DateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
+
+    public TimeDateUtils() {
+    }
+
+    /**
+     * 得到当前时间文本。
+     *
+     * @return 时间文本 格式{@link TimeDateUtils#getFormat()}
+     */
+    public static String getCurrentTime() {
+        return getTimeString(System.currentTimeMillis());
+    }
+
+    /**
+     * 得到一个时间戳的文本
+     *
+     * @param timeMillis 时间戳
+     * @return 时间文本 格式{@link TimeDateUtils#getFormat()}
+     */
+    public static String getTimeString(long timeMillis) {
+        return getFormat().format(new Date(timeMillis));
+    }
+
+    /**
+     * 得到一个日期时间的文本
+     *
+     * @param time 日期时间
+     * @return 时间文本 格式{@link TimeDateUtils#getFormat()}
+     */
+    public static String getTimeString(Date time) {
+        return getFormat().format(time);
+    }
+
+    /**
+     * 得到一个时间文本的时间戳
+     *
+     * @param timeString 时间文本
+     * @return 时间戳 格式{@link TimeDateUtils#getFormat()}
+     */
+    public static long parseTimeMillis(String timeString) {
+        if (timeString == null) {
+            return -1L;
+        } else {
+            try {
+                return format.parse(timeString).getTime();
+            } catch (ParseException var2) {
+                return -1L;
+            }
+        }
+    }
+
+
+    /**
+     * 得到一个时间文本的对应日期实例
+     *
+     * @param timeString 时间文本
+     * @return 日期实例 格式{@link TimeDateUtils#getFormat()}
+     */
+    public static Date getTimeDate(String timeString) {
+        if (timeString == null) {
+            return null;
+        } else {
+            try {
+                return format.parse(timeString);
+            } catch (ParseException var2) {
+                return null;
+            }
+        }
+    }
+
+    /**
+     * 将秒数转化为 DD:hh:mm:ss 格式
+     *
+     * @param allSeconds 秒数
+     * @return DD:hh:mm:ss格式文本
+     */
+    public static String toDHMSStyle(long allSeconds) {
+        long days = allSeconds / 86400L;
+        long hours = allSeconds % 86400L / 3600L;
+        long minutes = allSeconds % 3600L / 60L;
+        long seconds = allSeconds % 60L;
+        String DateTimes;
+        if (days > 0L) {
+            DateTimes = days + "天" + (hours > 0L ? hours + "小时" : "") + (minutes > 0L ? minutes + "分钟" : "") + (seconds > 0L ? seconds + "秒" : "");
+        } else if (hours > 0L) {
+            DateTimes = hours + "小时" + (minutes > 0L ? minutes + "分钟" : "") + (seconds > 0L ? seconds + "秒" : "");
+        } else if (minutes > 0L) {
+            DateTimes = minutes + "分钟" + (seconds > 0L ? seconds + "秒" : "");
+        } else {
+            DateTimes = seconds + "秒";
+        }
+
+        return DateTimes;
+    }
+
+    public static DateFormat getFormat() {
+        return format;
+    }
+}

api/src/main/java/cc/carm/lib/easysql/api/util/UUIDUtil.java

@@ -0,0 +1,15 @@
+package cc.carm.lib.easysql.api.util;
+
+import java.util.UUID;
+
+public class UUIDUtil {
+
+    public static UUID toUUID(String s) {
+        if (s.length() == 36) {
+            return UUID.fromString(s);
+        } else {
+            return UUID.fromString(s.substring(0, 8) + '-' + s.substring(8, 12) + '-' + s.substring(12, 16) + '-' + s.substring(16, 20) + '-' + s.substring(20));
+        }
+    }
+
+}