All Downloads are FREE. Search and download functionalities are using the official Maven repository.

com.xiaoleilu.hutool.db.sql.SqlBuilder Maven / Gradle / Ivy

package com.xiaoleilu.hutool.db.sql;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.Map.Entry;

import com.xiaoleilu.hutool.collection.CollectionUtil;
import com.xiaoleilu.hutool.db.DbRuntimeException;
import com.xiaoleilu.hutool.db.DbUtil;
import com.xiaoleilu.hutool.db.Entity;
import com.xiaoleilu.hutool.db.dialect.DialectName;
import com.xiaoleilu.hutool.log.Log;
import com.xiaoleilu.hutool.log.StaticLog;
import com.xiaoleilu.hutool.util.ArrayUtil;
import com.xiaoleilu.hutool.util.ObjectUtil;
import com.xiaoleilu.hutool.util.StrUtil;

/**
 * SQL构建器
* 首先拼接SQL语句,值使用 ? 占位
* 调用getParamValues()方法获得占位符对应的值 * * @author Looly * */ public class SqlBuilder { private final static Log log = StaticLog.get(); private static boolean showSql; private static boolean formatSql; //--------------------------------------------------------------- Static methods start /** * 创建SQL构建器 * @return SQL构建器 */ public static SqlBuilder create(){ return new SqlBuilder(); } /** * 创建SQL构建器 * @param wrapper 包装器 * @return SQL构建器 */ public static SqlBuilder create(Wrapper wrapper){ return new SqlBuilder(wrapper); } /** * 设置全局配置:是否通过debug日志显示SQL * @param isShowSql 是否显示SQL * @param isFormatSql 是否格式化显示的SQL */ public static void setShowSql(boolean isShowSql, boolean isFormatSql){ showSql = isShowSql; formatSql = isFormatSql; } //--------------------------------------------------------------- Static methods end //--------------------------------------------------------------- Enums start /** * SQL中多表关联用的关键字 * @author Looly * */ public static enum Join{ /** 如果表中有至少一个匹配,则返回行 */ INNER, /** 即使右表中没有匹配,也从左表返回所有的行 */ LEFT, /** 即使左表中没有匹配,也从右表返回所有的行 */ RIGHT, /** 只要其中一个表中存在匹配,就返回行 */ FULL } //--------------------------------------------------------------- Enums end final private StringBuilder sql = new StringBuilder(); /** 字段列表(仅用于插入和更新) */ final private List fields = new ArrayList(); /** 占位符对应的值列表 */ final private List paramValues = new ArrayList(); /** 包装器 */ private Wrapper wrapper; //--------------------------------------------------------------- Constructor start public SqlBuilder() { } public SqlBuilder(Wrapper wrapper) { this.wrapper = wrapper; } //--------------------------------------------------------------- Constructor end //--------------------------------------------------------------- Builder start /** * 插入,使用默认的ANSI方言 * @param entity 实体 * @return 自己 */ public SqlBuilder insert(Entity entity){ return this.insert(entity, DialectName.ANSI); } /** * 插入
* 插入会忽略空的字段名及其对应值,但是对于有字段名对应值为{@code null}的情况不忽略 * * @param entity 实体 * @param dialectName 方言名 * @return 自己 */ public SqlBuilder insert(Entity entity, DialectName dialectName){ //验证 DbUtil.validateEntity(entity); if(null != wrapper) { //包装表名 // entity = wrapper.wrap(entity); entity.setTableName(wrapper.wrap(entity.getTableName())); } final boolean isOracle = ObjectUtil.equal(dialectName, DialectName.ORACLE);//对Oracle的特殊处理 final StringBuilder fieldsPart = new StringBuilder(); final StringBuilder placeHolder = new StringBuilder(); boolean isFirst = true; String field; Object value; for (Entry entry : entity.entrySet()) { field = entry.getKey(); value = entry.getValue(); if(StrUtil.isNotBlank(field) /*&& null != value*/){ if(isFirst){ isFirst = false; }else{ //非第一个参数,追加逗号 fieldsPart.append(", "); placeHolder.append(", "); } this.fields.add(field); fieldsPart.append((null != wrapper) ? wrapper.wrap(field) : field); if(isOracle && value instanceof String && StrUtil.endWithIgnoreCase((String)value, ".nextval")) { //Oracle的特殊自增键,通过字段名.nextval获得下一个值 placeHolder.append(value); }else { placeHolder.append("?"); this.paramValues.add(value); } } } sql.append("INSERT INTO ")// .append(entity.getTableName()).append(" (").append(fieldsPart).append(") VALUES (")// .append(placeHolder.toString()).append(")"); return this; } /** * 删除 * @param tableName 表名 * @return 自己 */ public SqlBuilder delete(String tableName){ if(StrUtil.isBlank(tableName)) { throw new DbRuntimeException("Table name is blank !"); } if(null != wrapper) { //包装表名 tableName = wrapper.wrap(tableName); } sql.append("DELETE FROM ").append(tableName); return this; } /** * 更新 * @param entity 要更新的实体 * @return 自己 */ public SqlBuilder update(Entity entity){ //验证 DbUtil.validateEntity(entity); if(null != wrapper) { //包装表名 // entity = wrapper.wrap(entity); entity.setTableName(wrapper.wrap(entity.getTableName())); } sql.append("UPDATE ").append(entity.getTableName()).append(" SET "); String field; for (Entry entry : entity.entrySet()) { field = entry.getKey(); if(StrUtil.isNotBlank(field)){ if (paramValues.size() > 0) { sql.append(", "); } this.fields.add(field); sql.append((null != wrapper) ? wrapper.wrap(field) : field).append(" = ? "); this.paramValues.add(entry.getValue());//更新不对空做处理,因为存在清空字段的情况 } } return this; } /** * 查询 * @param isDistinct 是否添加DISTINCT关键字(查询唯一结果) * @param fields 查询的字段 * @return 自己 */ public SqlBuilder select(boolean isDistinct, String... fields){ return select(isDistinct, Arrays.asList(fields)); } /** * 查询 * @param isDistinct 是否添加DISTINCT关键字(查询唯一结果) * @param fields 查询的字段 * @return 自己 */ public SqlBuilder select(boolean isDistinct, Collection fields){ sql.append("SELECT "); if(isDistinct) { sql.append("DISTINCT "); } if (CollectionUtil.isEmpty(fields)) { sql.append("*"); } else { if(null != wrapper) { //包装字段名 fields = wrapper.wrap(fields); } sql.append(CollectionUtil.join(fields, StrUtil.COMMA)); } return this; } /** * 查询(非Distinct) * @param fields 查询的字段 * @return 自己 */ public SqlBuilder select(String... fields){ return select(false, fields); } /** * 查询(非Distinct) * @param fields 查询的字段 * @return 自己 */ public SqlBuilder select(Collection fields){ return select(false, fields); } /** * 添加 from语句 * @param tableNames 表名列表(多个表名用于多表查询) * @return 自己 */ public SqlBuilder from(String... tableNames){ if(ArrayUtil.isEmpty(tableNames) || StrUtil.hasBlank(tableNames)) { throw new DbRuntimeException("Table name is blank in table names !"); } if(null != wrapper) { //包装表名 tableNames = wrapper.wrap(tableNames); } sql.append(" FROM ").append(ArrayUtil.join(tableNames, StrUtil.COMMA)); return this; } /** * 添加Where语句
* 只支持单一的逻辑运算符(例如多个条件之间) * * @param logicalOperator 逻辑运算符 * @param conditions 条件,当条件为空时,只添加WHERE关键字 * @return 自己 */ public SqlBuilder where(LogicalOperator logicalOperator, Condition... conditions){ if(ArrayUtil.isNotEmpty(conditions)) { if(null != wrapper) { //包装字段名 conditions = wrapper.wrap(conditions); } where(buildCondition(logicalOperator, conditions)); } return this; } /** * 添加Where语句
* * @param where WHERE语句之后跟的条件语句字符串 * @return 自己 */ public SqlBuilder where(String where){ if(StrUtil.isNotBlank(where)){ sql.append(" WHERE ").append(where); } return this; } /** * 多值选择 * * @param 值类型 * @param field 字段名 * @param values 值列表 * @return 自身 */ @SuppressWarnings("unchecked") public SqlBuilder in(String field, T... values) { sql.append(wrapper.wrap(field)).append(" IN ").append("(").append(ArrayUtil.join(values, StrUtil.COMMA)).append(")"); return this; } /** * 分组 * @param fields 字段 * @return 自己 */ public SqlBuilder groupBy(String... fields){ if(ArrayUtil.isNotEmpty(fields)) { if(null != wrapper) { //包装字段名 fields = wrapper.wrap(fields); } sql.append(" GROUP BY ").append(ArrayUtil.join(fields, StrUtil.COMMA)); } return this; } /** * 添加Having语句 * @param logicalOperator 逻辑运算符 * @param conditions 条件 * @return 自己 */ public SqlBuilder having(LogicalOperator logicalOperator, Condition... conditions){ if(ArrayUtil.isNotEmpty(conditions)) { if(null != wrapper) { //包装字段名 conditions = wrapper.wrap(conditions); } having(buildCondition(logicalOperator, conditions)); } return this; } /** * 添加Having语句 * @param having 条件语句 * @return 自己 */ public SqlBuilder having(String having){ if(StrUtil.isNotBlank(having)){ sql.append(" HAVING ").append(having); } return this; } /** * 排序 * @param orders 排序对象 * @return 自己 */ public SqlBuilder orderBy(Order... orders){ if(ArrayUtil.isEmpty(orders)){ return this; } sql.append(" ORDER BY "); String field = null; boolean isFirst = true; for (Order order : orders) { if(null != wrapper) { //包装字段名 field = wrapper.wrap(order.getField()); } if(StrUtil.isBlank(field)){ continue; } //只有在非第一项前添加逗号 if (isFirst) { isFirst = false; } else { sql.append(StrUtil.COMMA); } sql.append(field); final Direction direction = order.getDirection(); if(null != direction){ sql.append(StrUtil.SPACE).append(direction); } } return this; } /** * 多表关联 * @param tableName 被关联的表名 * @param join 内联方式 * @return 自己 */ public SqlBuilder join(String tableName, Join join){ if(StrUtil.isBlank(tableName)) { throw new DbRuntimeException("Table name is blank !"); } if(null != join) { sql.append(StrUtil.SPACE).append(join).append(" JOIN "); if(null != wrapper) { //包装表名 tableName = wrapper.wrap(tableName); } sql.append(tableName); } return this; } /** * 配合JOIN的 ON语句,多表关联的条件语句
* 只支持单一的逻辑运算符(例如多个条件之间) * @param logicalOperator 逻辑运算符 * @param conditions 条件 * @return 自己 */ public SqlBuilder on(LogicalOperator logicalOperator, Condition... conditions){ if(ArrayUtil.isNotEmpty(conditions)) { if(null != wrapper) { //包装字段名 conditions = wrapper.wrap(conditions); } on(buildCondition(logicalOperator, conditions)); } return this; } /** * 配合JOIN的 ON语句,多表关联的条件语句
* 只支持单一的逻辑运算符(例如多个条件之间) * @param on 条件 * @return 自己 */ public SqlBuilder on(String on){ if(StrUtil.isNotBlank(on)){ this.sql.append(" ON ").append(on); } return this; } /** * 追加SQL其它部分 * @param sqlPart SQL其它部分 * @return 自己 */ public SqlBuilder append(Object sqlPart){ if(null != sqlPart) { this.sql.append(sqlPart); } return this; } /** * 构建查询SQL * @param query {@link Query} * @return this */ public SqlBuilder query(Query query){ return this .select(query.getFields()) .from(query.getTableNames()) .where(LogicalOperator.AND, query.getWhere()); } //--------------------------------------------------------------- Builder end /** * 获得插入或更新的数据库字段列表 * * @return 插入或更新的数据库字段列表 */ public List getFields() { return this.fields; } /** * 获得插入或更新的数据库字段列表 * * @return 插入或更新的数据库字段列表 */ public String[] getFieldArray() { return this.fields.toArray(new String[this.fields.size()]); } /** * 获得占位符对应的值列表
* @return 占位符对应的值列表 */ public List getParamValues() { return this.paramValues; } /** * 获得占位符对应的值列表
* @return 占位符对应的值列表 */ public Object[] getParamValueArray() { return this.paramValues.toArray(new Object[this.paramValues.size()]); } /** * 构建 * @return 构建好的SQL语句 */ public String build(){ return this.build(showSql); } /** * 构建 * @param isShowDebugSql 显示SQL的debug日志 * @return 构建好的SQL语句 */ public String build(boolean isShowDebugSql){ final String sqlStr = this.sql.toString().trim(); if(isShowDebugSql){ log.debug("\n{}", formatSql ? SqlFormatter.format(sqlStr) : sqlStr); } return sqlStr; } @Override public String toString() { return this.build(); } //--------------------------------------------------------------- private method start /** * 构建组合条件 * @param logicalOperator 逻辑运算符 * @param conditions 条件对象 * @return 构建后的SQL语句条件部分 */ private String buildCondition(LogicalOperator logicalOperator, Condition... conditions){ if(ArrayUtil.isEmpty(conditions)) { return StrUtil.EMPTY; } if(null == logicalOperator) { logicalOperator = LogicalOperator.AND; } final StringBuilder conditionStr = new StringBuilder(); boolean isFirst = true; for (Condition condition : conditions) { //添加逻辑运算符 if(isFirst){ isFirst = false; }else { conditionStr.append(StrUtil.SPACE).append(logicalOperator).append(StrUtil.SPACE); } if (condition.isBetween()) { //BETWEEN x AND y 的情况,两个参数 conditionStr.append(condition.getField()).append(StrUtil.SPACE); //处理 BETWEEN x conditionStr.append(condition.getOperator()); if (condition.isPlaceHolder()) { //使用条件表达式占位符 conditionStr.append(" ?"); paramValues.add(condition.getValue()); } else { //直接使用条件值 conditionStr.append(condition.getValue()); } //处理 AND y conditionStr.append(StrUtil.SPACE).append(LogicalOperator.AND.toString()); if (condition.isPlaceHolder()) { //使用条件表达式占位符 conditionStr.append(" ?"); paramValues.add(condition.getSecondValue()); } else { //直接使用条件值 conditionStr.append(condition.getSecondValue()); } } else { //其他情况,单一参数 //添加条件表达式 conditionStr.append(condition.getField()).append(StrUtil.SPACE).append(condition.getOperator()); if (condition.isPlaceHolder()) { //使用条件表达式占位符 conditionStr.append(" ?"); paramValues.add(condition.getValue()); } else { //直接使用条件值 conditionStr.append(condition.getValue()); } } } return conditionStr.toString(); } //--------------------------------------------------------------- private method end }