zhouxy108/hutool
1
0
Fork 0
mirror of https://gitee.com/chinabugotech/hutool.git synced 2025-08-18 20:38:02 +08:00
Code Issues Packages Projects Releases Wiki Activity

fix comment

Browse Source
This commit is contained in:
Looly
2019-10-08 18:16:30 +08:00
parent 1364656855
commit 0685a8a141
55 changed files with 2334 additions and 2106 deletions
Download Patch File Download Diff File Expand all files Collapse all files

252
hutool-db/src/main/java/cn/hutool/db/AbstractDb.java
View File

@@ -27,23 +27,25 @@ import cn.hutool.db.sql.Wrapper;
* 抽象数据库操作类<br>
* 通过给定的数据源执行给定SQL或者给定数据源和方言，执行相应的CRUD操作<br>
* 提供抽象方法getConnection和closeConnection，用于自定义数据库连接的打开和关闭
*
*
* @author Luxiaolei
*
*/
public abstract class AbstractDb implements Serializable{
public abstract class AbstractDb implements Serializable {
private static final long serialVersionUID = 3858951941916349062L;
protected DataSource ds;
/** 是否支持事务 */
/**
* 是否支持事务
*/
protected Boolean isSupportTransaction = null;
protected SqlConnRunner runner;
// ------------------------------------------------------- Constructor start
/**
* 构造
*
* @param ds 数据源
*
* @param ds 数据源
* @param dialect 数据库方言
*/
public AbstractDb(DataSource ds, Dialect dialect) {
@@ -54,7 +56,7 @@ public abstract class AbstractDb implements Serializable{
/**
* 获得链接。根据实现不同，可以自定义获取连接的方式
*
*
* @return {@link Connection}
* @throws SQLException 连接获取异常
*/
@@ -63,15 +65,15 @@ public abstract class AbstractDb implements Serializable{
/**
* 关闭连接<br>
* 自定义关闭连接有利于自定义回收连接机制，或者不关闭
*
*
* @param conn 连接 {@link Connection}
*/
public abstract void closeConnection(Connection conn);
/**
* 查询
*
* @param sql 查询语句
*
* @param sql 查询语句
* @param params 参数
* @return 结果对象
* @throws SQLException SQL执行异常
@@ -83,12 +85,11 @@ public abstract class AbstractDb implements Serializable{
/**
* 查询
*
* @param <T> 结果集需要处理的对象类型
*
* @param sql 查询语句
*
* @param <T> 结果集需要处理的对象类型
* @param sql 查询语句
* @param beanClass 元素Bean类型
* @param params 参数
* @param params 参数
* @return 结果对象
* @throws SQLException SQL执行异常
* @since 3.2.2
@@ -100,7 +101,7 @@ public abstract class AbstractDb implements Serializable{
/**
* 查询单条记录
*
* @param sql 查询语句
* @param sql 查询语句
* @param params 参数
* @return 结果对象
* @throws SQLException SQL执行异常
@@ -112,7 +113,7 @@ public abstract class AbstractDb implements Serializable{
/**
* 查询单条单个字段记录,并将其转换为Number
*
* @param sql 查询语句
* @param sql 查询语句
* @param params 参数
* @return 结果对象
* @throws SQLException SQL执行异常
@@ -124,7 +125,7 @@ public abstract class AbstractDb implements Serializable{
/**
* 查询单条单个字段记录,并将其转换为String
*
* @param sql 查询语句
* @param sql 查询语句
* @param params 参数
* @return 结果对象
* @throws SQLException SQL执行异常
@@ -135,10 +136,10 @@ public abstract class AbstractDb implements Serializable{
/**
* 查询
*
* @param <T> 结果集需要处理的对象类型
* @param sql 查询语句
* @param rsh 结果集处理对象
*
* @param <T> 结果集需要处理的对象类型
* @param sql 查询语句
* @param rsh 结果集处理对象
* @param params 参数
* @return 结果对象
* @throws SQLException SQL执行异常
@@ -156,8 +157,8 @@ public abstract class AbstractDb implements Serializable{
/**
* 执行非查询语句<br>
* 语句包括 插入、更新、删除
*
* @param sql SQL
*
* @param sql SQL
* @param params 参数
* @return 影响行数
* @throws SQLException SQL执行异常
@@ -175,8 +176,8 @@ public abstract class AbstractDb implements Serializable{
/**
* 执行非查询语句<br>
* 语句包括 插入、更新、删除
*
* @param sql SQL
*
* @param sql SQL
* @param params 参数
* @return 主键
* @throws SQLException SQL执行异常
@@ -193,8 +194,8 @@ public abstract class AbstractDb implements Serializable{
/**
* 批量执行非查询语句
*
* @param sql SQL
*
* @param sql SQL
* @param paramsBatch 批量的参数
* @return 每个SQL执行影响的行数
* @throws SQLException SQL执行异常
@@ -211,7 +212,7 @@ public abstract class AbstractDb implements Serializable{
/**
* 批量执行非查询语句
*
*
* @param sqls SQL列表
* @return 每个SQL执行影响的行数
* @throws SQLException SQL执行异常
@@ -228,9 +229,10 @@ public abstract class AbstractDb implements Serializable{
}
// ---------------------------------------------------------------------------- CRUD start
/**
* 插入数据
*
*
* @param record 记录
* @return 插入行数
* @throws SQLException SQL执行异常
@@ -248,9 +250,9 @@ public abstract class AbstractDb implements Serializable{
/**
* 插入或更新数据<br>
* 根据给定的字段名查询数据，如果存在则更新这些数据，否则执行插入
*
*
* @param record 记录
* @param keys 需要检查唯一性的字段
* @param keys 需要检查唯一性的字段
* @return 插入行数
* @throws SQLException SQL执行异常
* @since 4.0.10
@@ -269,7 +271,7 @@ public abstract class AbstractDb implements Serializable{
* 批量插入数据<br>
* 需要注意的是，批量插入每一条数据结构必须一致。批量插入数据时会获取第一条数据的字段结构，之后的数据会按照这个格式插入。<br>
* 也就是说假如第一条数据只有2个字段，后边数据多于这两个字段的部分将被抛弃。
*
*
* @param records 记录列表
* @return 插入行数
* @throws SQLException SQL执行异常
@@ -286,7 +288,7 @@ public abstract class AbstractDb implements Serializable{
/**
* 插入数据
*
*
* @param record 记录
* @return 主键列表
* @throws SQLException SQL执行异常
@@ -303,7 +305,7 @@ public abstract class AbstractDb implements Serializable{
/**
* 插入数据
*
*
* @param record 记录
* @return 主键
* @throws SQLException SQL执行异常
@@ -320,10 +322,10 @@ public abstract class AbstractDb implements Serializable{
/**
* 删除数据
*
*
* @param tableName 表名
* @param field 字段名，最好是主键
* @param value 值，值可以是列表或数组，被当作IN查询处理
* @param field 字段名，最好是主键
* @param value 值，值可以是列表或数组，被当作IN查询处理
* @return 删除行数
* @throws SQLException SQL执行异常
*/
@@ -333,7 +335,7 @@ public abstract class AbstractDb implements Serializable{
/**
* 删除数据
*
*
* @param where 条件
* @return 影响行数
* @throws SQLException SQL执行异常
@@ -351,9 +353,9 @@ public abstract class AbstractDb implements Serializable{
/**
* 更新数据<br>
* 更新条件为多个key value对表示，默认key = value，如果使用其它条件可以使用：where.put("key", " &gt; 1")，value也可以传Condition对象，key被忽略
*
*
* @param record 记录
* @param where 条件
* @param where 条件
* @return 影响行数
* @throws SQLException SQL执行异常
*/
@@ -368,14 +370,15 @@ public abstract class AbstractDb implements Serializable{
}
// ------------------------------------------------------------- Get start
/**
* 根据某个字段（最好是唯一字段）查询单个记录<br>
* 当有多条返回时，只显示查询到的第一条
*
* @param <T> 字段值类型
*
* @param <T> 字段值类型
* @param tableName 表名
* @param field 字段名
* @param value 字段值
* @param field 字段名
* @param value 字段值
* @return 记录
* @throws SQLException SQL执行异常
*/
@@ -385,7 +388,7 @@ public abstract class AbstractDb implements Serializable{
/**
* 根据条件实体查询单个记录，当有多条返回时，只显示查询到的第一条
*
*
* @param where 条件
* @return 记录
* @throws SQLException SQL执行异常
@@ -399,11 +402,11 @@ public abstract class AbstractDb implements Serializable{
/**
* 查询<br>
* 查询条件为多个key value对表示，默认key = value，如果使用其它条件可以使用：where.put("key", " &gt; 1")，value也可以传Condition对象，key被忽略
*
* @param <T> 需要处理成的结果对象类型
*
* @param <T> 需要处理成的结果对象类型
* @param fields 返回的字段列表，null则返回所有字段
* @param where 条件实体类（包含表名）
* @param rsh 结果集处理对象
* @param where 条件实体类（包含表名）
* @param rsh 结果集处理对象
* @return 结果对象
* @throws SQLException SQL执行异常
*/
@@ -416,13 +419,13 @@ public abstract class AbstractDb implements Serializable{
this.closeConnection(conn);
}
}
/**
* 查询<br>
* 查询条件为多个key value对表示，默认key = value，如果使用其它条件可以使用：where.put("key", " &gt; 1")，value也可以传Condition对象，key被忽略
*
*
* @param fields 返回的字段列表，null则返回所有字段
* @param where 条件实体类（包含表名）
* @param where 条件实体类（包含表名）
* @return 结果Entity列表
* @throws SQLException SQL执行异常
* @since 4.5.16
@@ -434,10 +437,10 @@ public abstract class AbstractDb implements Serializable{
/**
* 查询<br>
* Query为查询所需数据的一个实体类，此对象中可以定义返回字段、查询条件，查询的表、分页等信息
*
* @param <T> 需要处理成的结果对象类型
*
* @param <T> 需要处理成的结果对象类型
* @param query {@link Query}对象，此对象中可以定义返回字段、查询条件，查询的表、分页等信息
* @param rsh 结果集处理对象
* @param rsh 结果集处理对象
* @return 结果对象
* @throws SQLException SQL执行异常
* @since 4.0.0
@@ -455,10 +458,10 @@ public abstract class AbstractDb implements Serializable{
/**
* 查询，返回所有字段<br>
* 查询条件为多个key value对表示，默认key = value，如果使用其它条件可以使用：where.put("key", " &gt; 1")，value也可以传Condition对象，key被忽略
*
* @param <T> 需要处理成的结果对象类型
* @param where 条件实体类（包含表名）
* @param rsh 结果集处理对象
*
* @param <T> 需要处理成的结果对象类型
* @param where 条件实体类（包含表名）
* @param rsh 结果集处理对象
* @param fields 字段列表，可变长参数如果无值表示查询全部字段
* @return 结果对象
* @throws SQLException SQL执行异常
@@ -470,7 +473,7 @@ public abstract class AbstractDb implements Serializable{
/**
* 查询数据列表，返回字段由where参数指定<br>
* 查询条件为多个key value对表示，默认key = value，如果使用其它条件可以使用：where.put("key", " &gt; 1")，value也可以传Condition对象，key被忽略
*
*
* @param where 条件实体类（包含表名）
* @return 数据对象列表
* @throws SQLException SQL执行异常
@@ -483,9 +486,10 @@ public abstract class AbstractDb implements Serializable{
/**
* 查询数据列表，返回字段由where参数指定<br>
* 查询条件为多个key value对表示，默认key = value，如果使用其它条件可以使用：where.put("key", " &gt; 1")，value也可以传Condition对象，key被忽略
*
* @param <T> Bean类型
* @param where 条件实体类（包含表名）
*
* @param <T> Bean类型
* @param where 条件实体类（包含表名）
* @param beanClass Bean类
* @return 数据对象列表
* @throws SQLException SQL执行异常
* @since 3.2.2
@@ -497,7 +501,7 @@ public abstract class AbstractDb implements Serializable{
/**
* 查询数据列表，返回所有字段<br>
* 查询条件为多个key value对表示，默认key = value，如果使用其它条件可以使用：where.put("key", " &gt; 1")，value也可以传Condition对象，key被忽略
*
*
* @param where 条件实体类（包含表名）
* @return 数据对象列表
* @throws SQLException SQL执行异常
@@ -509,8 +513,8 @@ public abstract class AbstractDb implements Serializable{
/**
* 查询数据列表，返回所有字段<br>
* 查询条件为多个key value对表示，默认key = value，如果使用其它条件可以使用：where.put("key", " &gt; 1")，value也可以传Condition对象，key被忽略
*
* @param <T> Bean类型
*
* @param <T> Bean类型
* @param where 条件实体类（包含表名）
* @return 数据对象列表
* @throws SQLException SQL执行异常
@@ -522,7 +526,7 @@ public abstract class AbstractDb implements Serializable{
/**
* 查询数据列表，返回所有字段
*
*
* @param tableName 表名
* @return 数据对象列表
* @throws SQLException SQL执行异常
@@ -533,10 +537,10 @@ public abstract class AbstractDb implements Serializable{
/**
* 根据某个字段名条件查询数据列表，返回所有字段
*
*
* @param tableName 表名
* @param field 字段名
* @param value 字段值
* @param field 字段名
* @param value 字段值
* @return 数据对象列表
* @throws SQLException SQL执行异常
*/
@@ -546,9 +550,9 @@ public abstract class AbstractDb implements Serializable{
/**
* 根据多个条件查询数据列表，返回所有字段
*
*
* @param tableName 表名
* @param wheres 字段名
* @param wheres 字段名
* @return 数据对象列表
* @throws SQLException SQL执行异常
* @since 4.0.0
@@ -560,11 +564,11 @@ public abstract class AbstractDb implements Serializable{
/**
* 根据某个字段名条件查询数据列表，返回所有字段
*
*
* @param tableName 表名
* @param field 字段名
* @param value 字段值
* @param likeType {@link LikeType}
* @param field 字段名
* @param value 字段值
* @param likeType {@link LikeType}
* @return 数据对象列表
* @throws SQLException SQL执行异常
*/
@@ -574,7 +578,7 @@ public abstract class AbstractDb implements Serializable{
/**
* 结果的条目数
*
*
* @param where 查询条件
* @return 复合条件的结果数
* @throws SQLException SQL执行异常
@@ -592,13 +596,13 @@ public abstract class AbstractDb implements Serializable{
/**
* 分页查询<br>
* 查询条件为多个key value对表示，默认key = value，如果使用其它条件可以使用：where.put("key", " &gt; 1")，value也可以传Condition对象，key被忽略
*
* @param <T> 结果对象类型
* @param fields 返回的字段列表，null则返回所有字段
* @param where 条件实体类（包含表名）
* @param page 页码，0表示第一页
*
* @param <T> 结果对象类型
* @param fields 返回的字段列表，null则返回所有字段
* @param where 条件实体类（包含表名）
* @param page 页码，0表示第一页
* @param numPerPage 每页条目数
* @param rsh 结果集处理对象
* @param rsh 结果集处理对象
* @return 结果对象
* @throws SQLException SQL执行异常
*/
@@ -615,12 +619,12 @@ public abstract class AbstractDb implements Serializable{
/**
* 分页查询<br>
* 查询条件为多个key value对表示，默认key = value，如果使用其它条件可以使用：where.put("key", " &gt; 1")，value也可以传Condition对象，key被忽略
*
* @param <T> 结果对象类型
* @param where 条件实体类（包含表名）
* @param page 页码，0表示第一页
*
* @param <T> 结果对象类型
* @param where 条件实体类（包含表名）
* @param page 页码，0表示第一页
* @param numPerPage 每页条目数
* @param rsh 结果集处理对象
* @param rsh 结果集处理对象
* @return 结果对象
* @throws SQLException SQL执行异常
* @since 3.2.2
@@ -632,9 +636,9 @@ public abstract class AbstractDb implements Serializable{
/**
* 分页查询，结果为Entity列表，不计算总数<br>
* 查询条件为多个key value对表示，默认key = value，如果使用其它条件可以使用：where.put("key", " &gt; 1")，value也可以传Condition对象，key被忽略
*
* @param where 条件实体类（包含表名）
* @param page 页码，0表示第一页
*
* @param where 条件实体类（包含表名）
* @param page 页码，0表示第一页
* @param numPerPage 每页条目数
* @return 结果对象
* @throws SQLException SQL执行异常
@@ -647,9 +651,9 @@ public abstract class AbstractDb implements Serializable{
/**
* 分页查询，结果为Entity列表，不计算总数<br>
* 查询条件为多个key value对表示，默认key = value，如果使用其它条件可以使用：where.put("key", " &gt; 1")，value也可以传Condition对象，key被忽略
*
*
* @param where 条件实体类（包含表名）
* @param page 分页对象
* @param page 分页对象
* @return 结果对象
* @throws SQLException SQL执行异常
* @since 3.2.2
@@ -661,11 +665,11 @@ public abstract class AbstractDb implements Serializable{
/**
* 分页查询<br>
* 查询条件为多个key value对表示，默认key = value，如果使用其它条件可以使用：where.put("key", " &gt; 1")，value也可以传Condition对象，key被忽略
*
* @param <T> 结果对象类型
*
* @param <T> 结果对象类型
* @param where 条件实体类（包含表名）
* @param page 分页对象
* @param rsh 结果集处理对象
* @param page 分页对象
* @param rsh 结果集处理对象
* @return 结果对象
* @throws SQLException SQL执行异常
* @since 3.2.2
@@ -677,12 +681,12 @@ public abstract class AbstractDb implements Serializable{
/**
* 分页查询<br>
* 查询条件为多个key value对表示，默认key = value，如果使用其它条件可以使用：where.put("key", " &gt; 1")，value也可以传Condition对象，key被忽略
*
* @param <T> 结果对象类型
*
* @param <T> 结果对象类型
* @param fields 返回的字段列表，null则返回所有字段
* @param where 条件实体类（包含表名）
* @param page 分页对象
* @param rsh 结果集处理对象
* @param where 条件实体类（包含表名）
* @param page 分页对象
* @param rsh 结果集处理对象
* @return 结果对象
* @throws SQLException SQL执行异常
*/
@@ -699,10 +703,10 @@ public abstract class AbstractDb implements Serializable{
/**
* 分页查询<br>
* 查询条件为多个key value对表示，默认key = value，如果使用其它条件可以使用：where.put("key", " &gt; 1")，value也可以传Condition对象，key被忽略
*
* @param fields 返回的字段列表，null则返回所有字段
* @param where 条件实体类（包含表名）
* @param page 分页对象
*
* @param fields 返回的字段列表，null则返回所有字段
* @param where 条件实体类（包含表名）
* @param page 分页对象
* @param numPerPage 每页条目数
* @return 结果对象
* @throws SQLException SQL执行异常
@@ -720,10 +724,10 @@ public abstract class AbstractDb implements Serializable{
/**
* 分页查询<br>
* 查询条件为多个key value对表示，默认key = value，如果使用其它条件可以使用：where.put("key", " &gt; 1")，value也可以传Condition对象，key被忽略
*
*
* @param fields 返回的字段列表，null则返回所有字段
* @param where 条件实体类（包含表名）
* @param page 分页对象
* @param where 条件实体类（包含表名）
* @param page 分页对象
* @return 结果对象
* @throws SQLException SQL执行异常
*/
@@ -740,9 +744,9 @@ public abstract class AbstractDb implements Serializable{
/**
* 分页查询<br>
* 查询条件为多个key value对表示，默认key = value，如果使用其它条件可以使用：where.put("key", " &gt; 1")，value也可以传Condition对象，key被忽略
*
* @param where 条件实体类（包含表名）
* @param page 页码
*
* @param where 条件实体类（包含表名）
* @param page 页码
* @param numPerPage 每页条目数
* @return 分页结果集
* @throws SQLException SQL执行异常
@@ -755,9 +759,9 @@ public abstract class AbstractDb implements Serializable{
/**
* 分页查询<br>
* 查询条件为多个key value对表示，默认key = value，如果使用其它条件可以使用：where.put("key", " &gt; 1")，value也可以传Condition对象，key被忽略
*
*
* @param where 条件实体类（包含表名）
* @param page 分页对象
* @param page 分页对象
* @return 分页结果集
* @throws SQLException SQL执行异常
*/
@@ -767,9 +771,10 @@ public abstract class AbstractDb implements Serializable{
// ---------------------------------------------------------------------------- CRUD end
// ---------------------------------------------------------------------------- Getters and Setters start
/**
* 获取{@link SqlConnRunner}
*
*
* @return {@link SqlConnRunner}
*/
public SqlConnRunner getRunner() {
@@ -778,7 +783,7 @@ public abstract class AbstractDb implements Serializable{
/**
* 设置 {@link SqlConnRunner}
*
*
* @param runner {@link SqlConnRunner}
*/
public void setRunner(SqlConnRunner runner) {
@@ -787,7 +792,7 @@ public abstract class AbstractDb implements Serializable{
/**
* 设置包装器，包装器用于对表名、字段名进行符号包装（例如双引号），防止关键字与这些表名或字段冲突
*
*
* @param wrapperChar 包装字符，字符会在SQL生成时位于表名和字段名两边，null时表示取消包装
* @return this
* @since 4.0.0
@@ -798,7 +803,7 @@ public abstract class AbstractDb implements Serializable{
/**
* 设置包装器，包装器用于对表名、字段名进行符号包装（例如双引号），防止关键字与这些表名或字段冲突
*
*
* @param wrapper 包装器，null表示取消包装
* @return this
* @since 4.0.0
@@ -811,7 +816,7 @@ public abstract class AbstractDb implements Serializable{
/**
* 取消包装器<br>
* 取消自动添加到字段名、表名上的包装符（例如双引号）
*
*
* @return this
* @since 4.5.7
*/
@@ -821,11 +826,12 @@ public abstract class AbstractDb implements Serializable{
// ---------------------------------------------------------------------------- Getters and Setters end
// ---------------------------------------------------------------------------- protected method start
/**
* 检查数据库是否支持事务，此项检查同一个数据源只检查一次，如果不支持抛出DbRuntimeException异常
*
*
* @param conn Connection
* @throws SQLException 获取元数据信息失败
* @throws SQLException 获取元数据信息失败
* @throws DbRuntimeException 不支持事务
*/
protected void checkTransactionSupported(Connection conn) throws SQLException, DbRuntimeException {

11
hutool-db/src/main/java/cn/hutool/db/Session.java
View File

@@ -123,8 +123,6 @@ public class Session extends AbstractDb implements Closeable {
public void commit() throws SQLException {
try {
getConnection().commit();
} catch (SQLException e) {
throw e;
} finally {
try {
getConnection().setAutoCommit(true); // 事务结束，恢复自动提交
@@ -142,8 +140,6 @@ public class Session extends AbstractDb implements Closeable {
public void rollback() throws SQLException {
try {
getConnection().rollback();
} catch (SQLException e) {
throw e;
} finally {
try {
getConnection().setAutoCommit(true); // 事务结束，恢复自动提交
@@ -180,8 +176,6 @@ public class Session extends AbstractDb implements Closeable {
public void rollback(Savepoint savepoint) throws SQLException {
try {
getConnection().rollback(savepoint);
} catch (SQLException e) {
throw e;
} finally {
try {
getConnection().setAutoCommit(true); // 事务结束，恢复自动提交
@@ -195,9 +189,8 @@ public class Session extends AbstractDb implements Closeable {
* 静默回滚到某个保存点，保存点的设置请使用setSavepoint方法
*
* @param savepoint 保存点
* @throws SQLException SQL执行异常
*/
public void quietRollback(Savepoint savepoint) throws SQLException {
public void quietRollback(Savepoint savepoint) {
try {
getConnection().rollback(savepoint);
} catch (Exception e) {
@@ -255,7 +248,7 @@ public class Session extends AbstractDb implements Closeable {
* 在事务中执行操作，通过实现{@link VoidFunc0}接口的call方法执行多条SQL语句从而完成事务
*
* @param func 函数抽象，在函数中执行多个SQL操作，多个操作会被合并为同一事务
* @throws SQLException
* @throws SQLException SQL异常
* @since 3.2.3
*/
public void tx(VoidFunc1<Session> func) throws SQLException {

298
hutool-db/src/main/java/cn/hutool/db/SqlConnRunner.java
View File

@@ -28,72 +28,77 @@ import java.util.List;
* SQL执行类<br>
* 此执行类只接受方言参数，不需要数据源，只有在执行方法时需要数据库连接对象<br>
* 此对象存在的意义在于，可以由使用者自定义数据库连接对象，并执行多个方法，方便事务的统一控制或减少连接对象的创建关闭
*
* @author Luxiaolei
*
*/
public class SqlConnRunner{
public class SqlConnRunner {
private Dialect dialect;
/**
* 实例化一个新的SQL运行对象
*
*
* @param dialect 方言
* @return SQL执行类
*/
public static SqlConnRunner create(Dialect dialect) {
return new SqlConnRunner(dialect);
}
/**
* 实例化一个新的SQL运行对象
*
*
* @param ds 数据源
* @return SQL执行类
*/
public static SqlConnRunner create(DataSource ds) {
return new SqlConnRunner(DialectFactory.getDialect(ds));
}
/**
* 实例化一个新的SQL运行对象
*
*
* @param driverClassName 驱动类名
* @return SQL执行类
*/
public static SqlConnRunner create(String driverClassName) {
return new SqlConnRunner(driverClassName);
}
//------------------------------------------------------- Constructor start
/**
* 构造
*
* @param dialect 方言
*/
public SqlConnRunner(Dialect dialect) {
this.dialect = dialect;
}
/**
* 构造
*
* @param driverClassName 驱动类名，，用于识别方言
*/
public SqlConnRunner(String driverClassName) {
this(DialectFactory.newDialect(driverClassName));
}
//------------------------------------------------------- Constructor end
//---------------------------------------------------------------------------- CRUD start
/**
* 插入数据<br>
* 此方法不会关闭Connection
* @param conn 数据库连接
*
* @param conn 数据库连接
* @param record 记录
* @return 插入行数
* @throws SQLException SQL执行异常
*/
public int insert(Connection conn, Entity record) throws SQLException {
checkConn(conn);
if(CollectionUtil.isEmpty(record)){
if (CollectionUtil.isEmpty(record)) {
throw new SQLException("Empty entity provided!");
}
PreparedStatement ps = null;
@@ -104,33 +109,33 @@ public class SqlConnRunner{
DbUtil.close(ps);
}
}
/**
* 插入或更新数据<br>
* 此方法不会关闭Connection
*
* @param conn 数据库连接
*
* @param conn 数据库连接
* @param record 记录
* @param keys 需要检查唯一性的字段
* @param keys 需要检查唯一性的字段
* @return 插入行数
* @throws SQLException SQL执行异常
*/
public int insertOrUpdate(Connection conn, Entity record, String... keys) throws SQLException {
final Entity where = record.filter(keys);
if(MapUtil.isNotEmpty(where) && count(conn, where) > 0) {
if (MapUtil.isNotEmpty(where) && count(conn, where) > 0) {
return update(conn, record, where);
}else {
} else {
return insert(conn, record);
}
}
/**
* 批量插入数据<br>
* 需要注意的是，批量插入每一条数据结构必须一致。批量插入数据时会获取第一条数据的字段结构，之后的数据会按照这个格式插入。<br>
* 也就是说假如第一条数据只有2个字段，后边数据多于这两个字段的部分将被抛弃。
* 此方法不会关闭Connection
*
* @param conn 数据库连接
*
* @param conn 数据库连接
* @param records 记录列表，记录KV必须严格一致
* @return 插入行数
* @throws SQLException SQL执行异常
@@ -138,28 +143,28 @@ public class SqlConnRunner{
public int[] insert(Connection conn, Collection<Entity> records) throws SQLException {
return insert(conn, records.toArray(new Entity[records.size()]));
}
/**
* 批量插入数据<br>
* 批量插入必须严格保持Entity的结构一致，不一致会导致插入数据出现不可预知的结果<br>
* 此方法不会关闭Connection
*
* @param conn 数据库连接
*
* @param conn 数据库连接
* @param records 记录列表，记录KV必须严格一致
* @return 插入行数
* @throws SQLException SQL执行异常
*/
public int[] insert(Connection conn, Entity... records) throws SQLException {
checkConn(conn);
if(ArrayUtil.isEmpty(records)){
if (ArrayUtil.isEmpty(records)) {
return new int[]{0};
}
//单条单独处理
if(1 == records.length) {
return new int[] { insert(conn, records[0])};
if (1 == records.length) {
return new int[]{insert(conn, records[0])};
}
PreparedStatement ps = null;
try {
ps = dialect.psForInsertBatch(conn, records);
@@ -168,21 +173,22 @@ public class SqlConnRunner{
DbUtil.close(ps);
}
}
/**
* 插入数据<br>
* 此方法不会关闭Connection
* @param conn 数据库连接
*
* @param conn 数据库连接
* @param record 记录
* @return 主键列表
* @throws SQLException SQL执行异常
*/
public List<Object> insertForGeneratedKeys(Connection conn, Entity record) throws SQLException {
checkConn(conn);
if(CollectionUtil.isEmpty(record)){
if (CollectionUtil.isEmpty(record)) {
throw new SQLException("Empty entity provided!");
}
PreparedStatement ps = null;
try {
ps = dialect.psForInsert(conn, record);
@@ -192,21 +198,22 @@ public class SqlConnRunner{
DbUtil.close(ps);
}
}
/**
* 插入数据<br>
* 此方法不会关闭Connection
* @param conn 数据库连接
*
* @param conn 数据库连接
* @param record 记录
* @return 自增主键
* @throws SQLException SQL执行异常
*/
public Long insertForGeneratedKey(Connection conn, Entity record) throws SQLException {
checkConn(conn);
if(CollectionUtil.isEmpty(record)){
if (CollectionUtil.isEmpty(record)) {
throw new SQLException("Empty entity provided!");
}
PreparedStatement ps = null;
try {
ps = dialect.psForInsert(conn, record);
@@ -220,18 +227,19 @@ public class SqlConnRunner{
/**
* 删除数据<br>
* 此方法不会关闭Connection
* @param conn 数据库连接
*
* @param conn 数据库连接
* @param where 条件
* @return 影响行数
* @throws SQLException SQL执行异常
*/
public int del(Connection conn, Entity where) throws SQLException {
checkConn(conn);
if(CollectionUtil.isEmpty(where)){
if (CollectionUtil.isEmpty(where)) {
//不允许做全表删除
throw new SQLException("Empty entity provided!");
}
final Query query = new Query(SqlUtil.buildConditions(where), where.getTableName());
PreparedStatement ps = null;
try {
@@ -241,33 +249,34 @@ public class SqlConnRunner{
DbUtil.close(ps);
}
}
/**
* 更新数据<br>
* 此方法不会关闭Connection
* @param conn 数据库连接
*
* @param conn 数据库连接
* @param record 记录
* @param where 条件
* @param where 条件
* @return 影响行数
* @throws SQLException SQL执行异常
*/
public int update(Connection conn, Entity record, Entity where) throws SQLException {
checkConn(conn);
if(CollectionUtil.isEmpty(record)){
if (CollectionUtil.isEmpty(record)) {
throw new SQLException("Empty entity provided!");
}
if(CollectionUtil.isEmpty(where)){
if (CollectionUtil.isEmpty(where)) {
//不允许做全表更新
throw new SQLException("Empty where provided!");
}
//表名可以从被更新记录的Entity中获得，也可以从Where中获得
String tableName = record.getTableName();
if(StrUtil.isBlank(tableName)){
if (StrUtil.isBlank(tableName)) {
tableName = where.getTableName();
record.setTableName(tableName);
}
final Query query = new Query(SqlUtil.buildConditions(where), tableName);
PreparedStatement ps = null;
try {
@@ -277,22 +286,22 @@ public class SqlConnRunner{
DbUtil.close(ps);
}
}
/**
* 查询<br>
* 此方法不会关闭Connection
*
* @param <T> 结果对象类型
* @param conn 数据库连接对象
*
* @param <T> 结果对象类型
* @param conn 数据库连接对象
* @param query {@link Query}
* @param rsh 结果集处理对象
* @param rsh 结果集处理对象
* @return 结果对象
* @throws SQLException SQL执行异常
*/
public <T> T find(Connection conn, Query query, RsHandler<T> rsh) throws SQLException {
checkConn(conn);
Assert.notNull(query, "[query] is null !");
PreparedStatement ps = null;
try {
ps = dialect.psForFind(conn, query);
@@ -301,16 +310,16 @@ public class SqlConnRunner{
DbUtil.close(ps);
}
}
/**
* 查询<br>
* 此方法不会关闭Connection
*
* @param <T> 结果对象类型
* @param conn 数据库连接对象
*
* @param <T> 结果对象类型
* @param conn 数据库连接对象
* @param fields 返回的字段列表，null则返回所有字段
* @param where 条件实体类（包含表名）
* @param rsh 结果集处理对象
* @param where 条件实体类（包含表名）
* @param rsh 结果集处理对象
* @return 结果对象
* @throws SQLException SQL执行异常
*/
@@ -319,15 +328,15 @@ public class SqlConnRunner{
query.setFields(fields);
return find(conn, query, rsh);
}
/**
* 查询，返回指定字段列表<br>
* 此方法不会关闭Connection
*
* @param <T> 结果对象类型
* @param conn 数据库连接对象
* @param where 条件实体类（包含表名）
* @param rsh 结果集处理对象
*
* @param <T> 结果对象类型
* @param conn 数据库连接对象
* @param where 条件实体类（包含表名）
* @param rsh 结果集处理对象
* @param fields 字段列表，可变长参数如果无值表示查询全部字段
* @return 结果对象
* @throws SQLException SQL执行异常
@@ -335,97 +344,98 @@ public class SqlConnRunner{
public <T> T find(Connection conn, Entity where, RsHandler<T> rsh, String... fields) throws SQLException {
return find(conn, CollectionUtil.newArrayList(fields), where, rsh);
}
/**
* 查询数据列表，返回字段在where参数中定义
*
* @param conn 数据库连接对象
*
* @param conn 数据库连接对象
* @param where 条件实体类（包含表名）
* @return 数据对象列表
* @throws SQLException SQL执行异常
* @since 3.2.1
*/
public List<Entity> find(Connection conn, Entity where) throws SQLException{
public List<Entity> find(Connection conn, Entity where) throws SQLException {
return find(conn, where.getFieldNames(), where, EntityListHandler.create());
}
/**
* 查询数据列表，返回所有字段
*
* @param conn 数据库连接对象
*
* @param conn 数据库连接对象
* @param where 条件实体类（包含表名）
* @return 数据对象列表
* @throws SQLException SQL执行异常
*/
public List<Entity> findAll(Connection conn, Entity where) throws SQLException{
public List<Entity> findAll(Connection conn, Entity where) throws SQLException {
return find(conn, where, EntityListHandler.create());
}
/**
* 查询数据列表，返回所有字段
*
* @param conn 数据库连接对象
*
* @param conn 数据库连接对象
* @param tableName 表名
* @return 数据对象列表
* @throws SQLException SQL执行异常
*/
public List<Entity> findAll(Connection conn, String tableName) throws SQLException{
public List<Entity> findAll(Connection conn, String tableName) throws SQLException {
return findAll(conn, Entity.create(tableName));
}
/**
* 根据某个字段名条件查询数据列表，返回所有字段
*
* @param conn 数据库连接对象
*
* @param conn 数据库连接对象
* @param tableName 表名
* @param field 字段名
* @param value 字段值
* @param field 字段名
* @param value 字段值
* @return 数据对象列表
* @throws SQLException SQL执行异常
*/
public List<Entity> findBy(Connection conn, String tableName, String field, Object value) throws SQLException{
public List<Entity> findBy(Connection conn, String tableName, String field, Object value) throws SQLException {
return findAll(conn, Entity.create(tableName).set(field, value));
}
/**
* 根据某个字段名条件查询数据列表，返回所有字段
*
* @param conn 数据库连接对象
*
* @param conn 数据库连接对象
* @param tableName 表名
* @param field 字段名
* @param value 字段值
* @param likeType {@link LikeType}
* @param field 字段名
* @param value 字段值
* @param likeType {@link LikeType}
* @return 数据对象列表
* @throws SQLException SQL执行异常
*/
public List<Entity> findLike(Connection conn, String tableName, String field, String value, LikeType likeType) throws SQLException{
public List<Entity> findLike(Connection conn, String tableName, String field, String value, LikeType likeType) throws SQLException {
return findAll(conn, Entity.create(tableName).set(field, SqlUtil.buildLikeValue(value, likeType, true)));
}
/**
* 根据某个字段名条件查询数据列表，返回所有字段
*
* @param conn 数据库连接对象
*
* @param conn 数据库连接对象
* @param tableName 表名
* @param field 字段名
* @param values 字段值列表
* @param field 字段名
* @param values 字段值列表
* @return 数据对象列表
* @throws SQLException SQL执行异常
*/
public List<Entity> findIn(Connection conn, String tableName, String field, Object... values) throws SQLException{
public List<Entity> findIn(Connection conn, String tableName, String field, Object... values) throws SQLException {
return findAll(conn, Entity.create(tableName).set(field, values));
}
/**
* 结果的条目数
* @param conn 数据库连接对象
*
* @param conn 数据库连接对象
* @param where 查询条件
* @return 复合条件的结果数
* @throws SQLException SQL执行异常
*/
public int count(Connection conn, Entity where) throws SQLException {
checkConn(conn);
final Query query = new Query(SqlUtil.buildConditions(where), where.getTableName());
PreparedStatement ps = null;
try {
@@ -435,104 +445,104 @@ public class SqlConnRunner{
DbUtil.close(ps);
}
}
/**
* 分页查询<br>
* 此方法不会关闭Connection
*
* @param <T> 结果对象类型
* @param conn 数据库连接对象
* @param fields 返回的字段列表，null则返回所有字段
* @param where 条件实体类（包含表名）
*
* @param <T> 结果对象类型
* @param conn 数据库连接对象
* @param fields 返回的字段列表，null则返回所有字段
* @param where 条件实体类（包含表名）
* @param pageNumber 页码
* @param numPerPage 每页条目数
* @param rsh 结果集处理对象
* @param rsh 结果集处理对象
* @return 结果对象
* @throws SQLException SQL执行异常
*/
public <T> T page(Connection conn, Collection<String> fields, Entity where, int pageNumber, int numPerPage, RsHandler<T> rsh) throws SQLException {
return page(conn, fields, where, new Page(pageNumber, numPerPage), rsh);
}
/**
* 分页查询<br>
* 此方法不会关闭Connection
*
* @param <T> 结果对象类型
* @param conn 数据库连接对象
*
* @param <T> 结果对象类型
* @param conn 数据库连接对象
* @param fields 返回的字段列表，null则返回所有字段
* @param where 条件实体类（包含表名）
* @param page 分页对象
* @param rsh 结果集处理对象
* @param where 条件实体类（包含表名）
* @param page 分页对象
* @param rsh 结果集处理对象
* @return 结果对象
* @throws SQLException SQL执行异常
*/
public <T> T page(Connection conn, Collection<String> fields, Entity where, Page page, RsHandler<T> rsh) throws SQLException {
checkConn(conn);
if(null == page){
if (null == page) {
return this.find(conn, fields, where, rsh);
}
final Query query = new Query(SqlUtil.buildConditions(where), where.getTableName());
query.setFields(fields);
query.setPage(page);
return SqlExecutor.queryAndClosePs(dialect.psForPage(conn, query), rsh);
}
/**
* 分页查询<br>
* 此方法不会关闭Connection
*
* @param conn 数据库连接对象
* @param fields 返回的字段列表，null则返回所有字段
* @param where 条件实体类（包含表名）
* @param page 页码
*
* @param conn 数据库连接对象
* @param fields 返回的字段列表，null则返回所有字段
* @param where 条件实体类（包含表名）
* @param page 页码
* @param numPerPage 每页条目数
* @return 结果对象
* @throws SQLException SQL执行异常
*/
public PageResult<Entity> page(Connection conn, Collection<String> fields, Entity where, int page, int numPerPage) throws SQLException {
checkConn(conn);
final int count = count(conn, where);
PageResultHandler pageResultHandler = PageResultHandler.create(new PageResult<Entity>(page, numPerPage, count));
return this.page(conn, fields, where, page, numPerPage, pageResultHandler);
}
/**
* 分页查询<br>
* 此方法不会关闭Connection
*
* @param conn 数据库连接对象
*
* @param conn 数据库连接对象
* @param fields 返回的字段列表，null则返回所有字段
* @param where 条件实体类（包含表名）
* @param page 分页对象
* @param where 条件实体类（包含表名）
* @param page 分页对象
* @return 结果对象
* @throws SQLException SQL执行异常
*/
public PageResult<Entity> page(Connection conn, Collection<String> fields, Entity where, Page page) throws SQLException {
checkConn(conn);
//查询全部
if(null == page){
if (null == page) {
List<Entity> entityList = this.find(conn, fields, where, new EntityListHandler());
final PageResult<Entity> pageResult = new PageResult<>(0, entityList.size(), entityList.size());
pageResult.addAll(entityList);
return pageResult;
}
final int count = count(conn, where);
PageResultHandler pageResultHandler = PageResultHandler.create(new PageResult<Entity>(page.getPageNumber(), page.getPageSize(), count));
return this.page(conn, fields, where, page, pageResultHandler);
}
/**
* 分页全字段查询<br>
* 此方法不会关闭Connection
*
* @param conn 数据库连接对象
*
* @param conn 数据库连接对象
* @param where 条件实体类（包含表名）
* @param page 分页对象
* @param page 分页对象
* @return 结果对象
* @throws SQLException SQL执行异常
*/
@@ -540,25 +550,30 @@ public class SqlConnRunner{
return this.page(conn, null, where, page);
}
//---------------------------------------------------------------------------- CRUD end
//---------------------------------------------------------------------------- Getters and Setters end
/**
* @return SQL方言
*/
public Dialect getDialect() {
return dialect;
}
/**
* 设置SQL方言
*
* @param dialect 方言
* @return this
*/
public SqlConnRunner setDialect(Dialect dialect) {
this.dialect = dialect;
return this;
}
/**
* 设置包装器，包装器用于对表名、字段名进行符号包装（例如双引号），防止关键字与这些表名或字段冲突
*
* @param wrapperChar 包装字符，字符会在SQL生成时位于表名和字段名两边，null时表示取消包装
* @return this
* @since 4.0.0
@@ -566,9 +581,10 @@ public class SqlConnRunner{
public SqlConnRunner setWrapper(Character wrapperChar) {
return setWrapper(new Wrapper(wrapperChar));
}
/**
* 设置包装器，包装器用于对表名、字段名进行符号包装（例如双引号），防止关键字与这些表名或字段冲突
*
* @param wrapper 包装器，null表示取消包装
* @return this
* @since 4.0.0
@@ -578,10 +594,10 @@ public class SqlConnRunner{
return this;
}
//---------------------------------------------------------------------------- Getters and Setters end
//---------------------------------------------------------------------------- Private method start
private void checkConn(Connection conn){
if(null == conn){
private void checkConn(Connection conn) {
if (null == conn) {
throw new NullPointerException("Connection object is null!");
}
}

2
hutool-db/src/main/java/cn/hutool/db/ThreadLocalConnection.java
View File

@@ -68,7 +68,7 @@ public enum ThreadLocalConnection {
*
* @param ds 数据源
* @return Connection
* @throws SQLException
* @throws SQLException SQL异常
*/
public Connection get(DataSource ds) throws SQLException {
Connection conn = connMap.get(ds);

4
hutool-db/src/main/java/cn/hutool/db/ds/DSFactory.java
View File

@@ -140,7 +140,7 @@ public abstract class DSFactory implements Closeable, Serializable{
/**
* 创建数据源实现工厂<br>
* 此方法通过“试错”方式查找引入项目的连接池库，按照优先级寻找，一旦寻找到则创建对应的数据源工厂<br>
* 连接池优先级：Hikari > Druid > Tomcat > Dbcp > C3p0 > Hutool Pooled
* 连接池优先级：Hikari &gt; Druid &gt; Tomcat &gt; Dbcp &gt; C3p0 &gt; Hutool Pooled
*
* @return 日志实现类
*/
@@ -153,7 +153,7 @@ public abstract class DSFactory implements Closeable, Serializable{
/**
* 创建数据源实现工厂<br>
* 此方法通过“试错”方式查找引入项目的连接池库，按照优先级寻找，一旦寻找到则创建对应的数据源工厂<br>
* 连接池优先级：Hikari > Druid > Tomcat > Dbcp > C3p0 > Hutool Pooled
* 连接池优先级：Hikari &gt; Druid &gt; Tomcat &gt; Dbcp &gt; C3p0 &gt; Hutool Pooled
*
* @return 日志实现类
* @since 4.1.3

17
hutool-db/src/main/java/cn/hutool/db/ds/DataSourceWrapper.java
View File

@@ -13,11 +13,11 @@ import cn.hutool.core.io.IoUtil;
/**
* {@link DataSource} 数据源实现包装，通过包装，提供基本功能外的额外功能和参数持有，包括：
*
*
* <pre>
* 1. 提供驱动名的持有，用于确定数据库方言
* </pre>
*
*
* @author looly
* @since 4.3.2
*/
@@ -28,9 +28,10 @@ public class DataSourceWrapper implements DataSource, Closeable, Cloneable {
/**
* 包装指定的DataSource
*
* @param ds 原始的DataSource
*
* @param ds 原始的DataSource
* @param driver 数据库驱动类名
* @return {@link DataSourceWrapper}
*/
public static DataSourceWrapper wrap(DataSource ds, String driver) {
return new DataSourceWrapper(ds, driver);
@@ -38,8 +39,8 @@ public class DataSourceWrapper implements DataSource, Closeable, Cloneable {
/**
* 构造
*
* @param ds 原始的DataSource
*
* @param ds 原始的DataSource
* @param driver 数据库驱动类名
*/
public DataSourceWrapper(DataSource ds, String driver) {
@@ -49,7 +50,7 @@ public class DataSourceWrapper implements DataSource, Closeable, Cloneable {
/**
* 获取驱动名
*
*
* @return 驱动名
*/
public String getDriver() {
@@ -58,7 +59,7 @@ public class DataSourceWrapper implements DataSource, Closeable, Cloneable {
/**
* 获取原始的数据源
*
*
* @return 原始数据源
*/
public DataSource getRaw() {

10
hutool-db/src/main/java/cn/hutool/db/handler/HandleHelper.java
View File

@@ -29,7 +29,8 @@ public class HandleHelper {
/**
* 处理单条数据
*
*
* @param <T> Bean类型
* @param columnCount 列数
* @param meta ResultSetMetaData
* @param rs 数据集
@@ -44,7 +45,8 @@ public class HandleHelper {
/**
* 处理单条数据
*
*
* @param <T> Bean类型
* @param columnCount 列数
* @param meta ResultSetMetaData
* @param rs 数据集
@@ -84,8 +86,8 @@ public class HandleHelper {
final Map<String, PropDesc> propMap = BeanUtil.getBeanDesc(beanClass).getPropMap(true);
String columnLabel;
PropDesc pd;
Method setter = null;
Object value = null;
Method setter;
Object value;
for (int i = 1; i <= columnCount; i++) {
columnLabel = meta.getColumnLabel(i);
pd = propMap.get(columnLabel);

1
hutool-db/src/main/java/cn/hutool/db/sql/SqlLog.java
View File

@@ -30,6 +30,7 @@ public enum SqlLog {
* @param isShowSql 是否显示SQL
* @param isFormatSql 是否格式化显示的SQL
* @param isShowParams 是否打印参数
* @param level 日志级别
*/
public void init(boolean isShowSql, boolean isFormatSql, boolean isShowParams, Level level) {
this.showSql = isShowSql;

67
hutool-db/src/main/java/cn/hutool/db/sql/SqlUtil.java
View File

@@ -21,7 +21,7 @@ import cn.hutool.db.sql.Condition.LikeType;
/**
* SQL相关工具类，包括相关SQL语句拼接等
*
*
* @author looly
* @since 4.0.10
*/
@@ -30,8 +30,8 @@ public class SqlUtil {
/**
* 构件相等条件的where语句<br>
* 如果没有条件语句，泽返回空串，表示没有条件
*
* @param entity 条件实体
*
* @param entity 条件实体
* @param paramValues 条件值得存放List
* @return 带where关键字的SQL部分
*/
@@ -57,7 +57,7 @@ public class SqlUtil {
/**
* 通过实体对象构建条件对象
*
*
* @param entity 实体对象
* @return 条件对象
*/
@@ -83,23 +83,24 @@ public class SqlUtil {
/**
* 创建LIKE语句中的值，创建的结果为：
*
*
* <pre>
* 1、LikeType.StartWith: %value
* 2、LikeType.EndWith: value%
* 3、LikeType.Contains: %value%
* </pre>
*
* <p>
* 如果withLikeKeyword为true，则结果为：
*
*
* <pre>
* 1、LikeType.StartWith: LIKE %value
* 2、LikeType.EndWith: LIKE value%
* 3、LikeType.Contains: LIKE %value%
* </pre>
*
* @param value 被查找值
* @param likeType LIKE值类型 {@link LikeType}
*
* @param value 被查找值
* @param likeType LIKE值类型 {@link LikeType}
* @param withLikeKeyword 是否包含LIKE关键字
* @return 拼接后的like值
*/
public static String buildLikeValue(String value, LikeType likeType, boolean withLikeKeyword) {
@@ -109,25 +110,25 @@ public class SqlUtil {
StringBuilder likeValue = StrUtil.builder(withLikeKeyword ? "LIKE " : "");
switch (likeType) {
case StartWith:
likeValue.append('%').append(value);
break;
case EndWith:
likeValue.append(value).append('%');
break;
case Contains:
likeValue.append('%').append(value).append('%');
break;
case StartWith:
likeValue.append('%').append(value);
break;
case EndWith:
likeValue.append(value).append('%');
break;
case Contains:
likeValue.append('%').append(value).append('%');
break;
default:
break;
default:
break;
}
return likeValue.toString();
}
/**
* 格式化SQL
*
*
* @param sql SQL
* @return 格式化后的SQL
*/
@@ -137,7 +138,7 @@ public class SqlUtil {
/**
* 将RowId转为字符串
*
*
* @param rowId RowId
* @return RowId字符串
*/
@@ -147,7 +148,7 @@ public class SqlUtil {
/**
* Clob字段值转字符串
*
*
* @param clob {@link Clob}
* @return 字符串
* @since 3.0.6
@@ -166,8 +167,8 @@ public class SqlUtil {
/**
* Blob字段值转字符串
*
* @param blob {@link Blob}
*
* @param blob {@link Blob}
* @param charset 编码
* @return 字符串
* @since 3.0.6
@@ -186,9 +187,9 @@ public class SqlUtil {
/**
* 创建Blob对象
*
* @param conn {@link Connection}
* @param dataStream 数据流，使用完毕后关闭
*
* @param conn {@link Connection}
* @param dataStream 数据流，使用完毕后关闭
* @param closeAfterUse 使用完毕是否关闭流
* @return {@link Blob}
* @since 4.5.13
@@ -210,10 +211,10 @@ public class SqlUtil {
}
return blob;
}
/**
* 创建Blob对象
*
*
* @param conn {@link Connection}
* @param data 数据
* @return {@link Blob}
@@ -232,7 +233,7 @@ public class SqlUtil {
/**
* 转换为{@link java.sql.Date}
*
*
* @param date {@link java.util.Date}
* @return {@link java.sql.Date}
* @since 3.1.2
@@ -243,7 +244,7 @@ public class SqlUtil {
/**
* 转换为{@link java.sql.Timestamp}
*
*
* @param date {@link java.util.Date}
* @return {@link java.sql.Timestamp}
* @since 3.1.2