`
liyonghui160com
  • 浏览: 775766 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

SQLQueryUtil

    博客分类:
  • java
阅读更多

 

 

import java.util.ArrayList;
import java.util.HashMap;
import java.util.IdentityHashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

import org.apache.commons.lang3.StringUtils;


public class SQLQueryUtil {

    private static final long serialVersionUID = -4008847394285279230L;

    private static String USE_JDBC_DRIVER = "mysql";

    /**
     * main()
     *
     * @param args
     */
    public static void main(String[] args) {
        SQLQueryUtil util = new SQLQueryUtil();
        util.addTable("mydb.user","mydb.user");
        util.addTable("mydb.group", "mydb.group");

        util.addColumn("SUM(group.name)","sum_name");
        util.addColumn("COUNT(group.name)","count_name");
        util.addColumn("user.name", "user_name");

        util.addAndCondition("user.id", RelationalOperators.EQ, "123", ValueType.NUMBER);
        //util.addAndInCondition("user_age", "'x','x','x','x','x'");
        //util.addOrLikeCondition("like", "yyyy");
        util.addGroupBy("group.name");
        util.addAscOrderBy("create_time");
        util.addDescOrderBy("user.id");
        System.out.println(util.toSQL());
    }

    /**
     * 日期格式化字符串 如:2013-06-20
     */
    public static final String FMT_DATE = "yyyy-MM-dd";

    /**
     * 时间格式化字符串 如:13:01:01
     */
    public static final String FMT_TIME = "HH:mm:ss";

    /**
     * 日期时间格式化字符串 如:2013-06-20 13:01:01
     */
    public static final String FMT_DATETIME = "yyyy-MM-dd HH:mm:ss";

    /**
     * 逻辑运算
     *
     * @author Vity
     *
     */
    public enum LogicalOperators {
        AND("AND"), OR("OR");
        private String value;

        private LogicalOperators(String value) {
            this.value = value;
        }

        public String toString() {
            return new String(this.value);
        }
    }

    /**
     * 关系运算
     *
     * <p>
     * EQ("="), NE("<>"), GT(">"), GE(">="), LT("<"), LE("<=")
     * </p>
     *
     * @author Vity
     *
     */
    public enum RelationalOperators {
        EQ("="), NE("<>"), GT(">"), GE(">="), LT("<"), LE("<=");
        private String value;

        private RelationalOperators(String value) {
            this.value = value;
        }

        public String toString() {
            return this.value;
        }
    }

    /**
     * 排序方式
     *
     * @author Vity
     *
     */
    public enum SortMethod {
        ASC("ASC"), DESC("DESC");
        private String value;

        private SortMethod(String value) {
            this.value = value;
        }

        public String toString() {
            return this.value;
        }
    }

    /**
     * 值类型
     *
     * @author Vity
     *
     */
    public enum ValueType {
        NUMBER, DATE, STRING, TIME, DATETIME
    }

    /**
     * 内置表别名前缀
     */
    private final String TABLE_ALIAS_NAME = "TEMP_TABLE_ALIAS_";

    /**
     * 内置表别名索引
     */
    private int TABLE_ALIAS_INDEX = 0;

    /**
     * 是否调试模式 非调试模式则不打印SQL语句
     */
    private boolean isDebug = true;

    /**
     * 是否去重
     */
    private boolean isDistinct = false;

    /**
     * 表名及别名集合 key : table & view name | value : alias name
     * <p>
     * <b>注意:</b>目前不支持重复表查询
     * </p>
     */
    private Map<String, String> tableMap = new HashMap<String, String>();

    /**
     * 待查列名集合 key : column name value : | alias name
     */
    private Map<String, String> columnMap = new HashMap<String, String>();

    /**
     * 查询条件集合 key : and & or | value 条件值
     */
    private Map<String, String> conditionMap = new IdentityHashMap<String, String>();

    /**
     * 排序条件集合
     */
    private Map<String, String> orderMap = new HashMap<String, String>();

    /**
     * 分组集合
     */
    private List<String> groupList = new ArrayList<String>();


    /**
     * sql生成结果
     */
    private StringBuilder sqlResult = new StringBuilder();

    /**
     * 追加字符串,在后面添加一个空格
     *
     * @param string
     * @return
     */
    private SQLQueryUtil append(String string) {
        sqlResult.append(string).append(" ");
        return this;
    }

    /**
     * 删除最后两位字符串
     *
     * @return
     */
    private SQLQueryUtil clearEndChar() {
        sqlResult.delete(sqlResult.length() - 2, sqlResult.length());
        return this;
    }

    /**
     * 生成SQL语句
     *
     * @return
     */
    public String toSQL() {
        if (tableMap.isEmpty()) {
            //throw new Exception("Failure", "未发现表或视图");
        }

        this.append("SELECT");

        if (isDistinct) {
            this.append("DISTINCT");
        }

        if (columnMap.isEmpty()) {
            this.append("*");
        } else {
            for (String key : columnMap.keySet()) {
                this.append(key);
                if (!StringUtils.isBlank(columnMap.get(key))) {
                    this.append("AS").append(columnMap.get(key));
                }
                this.append(",");
            }
            this.clearEndChar();
        }



        this.append("FROM");

        for (String key : tableMap.keySet()) {
            this.append(key);
            if (!StringUtils.isBlank(tableMap.get(key))) {
                this.append("AS").append(tableMap.get(key));
            }
            this.append(",");
        }
        this.clearEndChar().append(" ");

        if (!groupList.isEmpty()) {
            this.append("GROUP BY");
            for (String field : groupList) {
                this.append(field).append(",");
            }
            this.clearEndChar();
        }

        if (!conditionMap.isEmpty()) {
            if (!groupList.isEmpty()) {
                this.append("HAVING");
            } else {
                this.append("WHERE");
            }
            this.append("1 = 1");
            for (Entry<String, String> entry : conditionMap.entrySet()) {
                this.append(entry.getKey()).append(entry.getValue());
            }
        }

        if (!orderMap.isEmpty()) {
            this.append("ORDER BY");
            for (String key : orderMap.keySet()) {
                this.append(key).append(orderMap.get(key)).append(",");
            }
            this.clearEndChar();
        }

        if (isDebug) {
            //logger.trace(sqlResult.toString().replace(" ,", ",").replace("  ", " ").replace(" 1 = 1 AND", "").replace(" 1 = 1 OR", ""));
        }
        return sqlResult.toString().replace(" ,", ",").replace("  ", " ").replace(" 1 = 1 AND", "").replace(" 1 = 1 OR", "");
    }

    /**
     * 设置 是否Distinct查询
     *
     * @param isDistinct
     */
    public void setDistinct(boolean isDistinct) {
        this.isDistinct = isDistinct;
    }

    /**
     * 添加待查询的表或视图名称
     *
     * @param tableName
     * @return
     */
    public SQLQueryUtil addTable(String tableName) {
        tableMap.put(tableName, TABLE_ALIAS_NAME + TABLE_ALIAS_INDEX++);
        return this;
    }

    /**
     * 添加待查询的表或视图名称,并指定别名
     *
     * @param tableName
     * @param aliasName
     * @return
     */
    public SQLQueryUtil addTable(String tableName, String aliasName) {
        if (aliasName.contains(TABLE_ALIAS_NAME)) {
            //throw new AppException(ResultCode.Failure, "不能使用这个别名前缀:" + TABLE_ALIAS_NAME);
        }
        tableMap.put(tableName, aliasName);
        return this;
    }

    /**
     * 添加待查列
     *
     * @param columnName
     * @return
     */
    public SQLQueryUtil addColumn(String columnName) {
        return this.addColumn(columnName, "");
    }

    /**
     * 添加待查列,并指定别名
     *
     * @param columnName
     * @param aliasName
     * @return
     */
    public SQLQueryUtil addColumn(String columnName, String aliasName) {
        columnMap.put(columnName, aliasName);
        return this;
    }

    /**
     * 添加查询条件
     *
     * <p>
     * <span>针对日期类型查询的说明</span> <div>
     * 日期查询必须将查询值按照本类提供的格式化字符串进行格式化,并指定相应的ValueType </div>
     * </p>
     *
     * @param logicalOperators
     * @param cKey
     * @param relationalOperators
     * @param cValue
     * @param valueType
     * @return
     */
    private SQLQueryUtil addCondition(LogicalOperators logicalOperators, String cKey, RelationalOperators relationalOperators, String cValue,
                                      ValueType valueType) {
        switch (valueType) {
            case STRING:
                conditionMap.put(logicalOperators.toString(),
                        cKey.concat(" ").concat(relationalOperators.toString()).concat(" '").concat(cValue).concat("'"));
                break;
            case NUMBER:
                conditionMap.put(logicalOperators.toString(), cKey.concat(" ").concat(relationalOperators.toString()).concat(" ").concat(cValue));
                break;
            default:
                conditionMap.put(logicalOperators.toString(), this.getDateTimeQuery(cKey, relationalOperators, cValue, valueType));
                break;

        }
        return this;
    }

    /**
     * 目前仅支持 Oracle, MySQL ; 日期查询生成 其他数据库方式请根据需要自行扩展
     */
    private String getDateTimeQuery(String cKey, RelationalOperators ro, String cValue, ValueType vt) {
        if (USE_JDBC_DRIVER.toLowerCase().contains("oracle")) {
            switch (vt) {
                case DATE:
                    return "to_char(".concat(cKey).concat(",'yyyy-mm-dd')").concat(ro.toString()).concat("'").concat(cValue).concat("'");
                case TIME:
                    return "to_char(".concat(cKey).concat(",'hh24:mi:ss')").concat(ro.toString()).concat("'").concat(cValue).concat("'");
                case DATETIME:
                    return "to_char(".concat(cKey).concat(",'yyyy-mm-dd hh24:mi:ss')").concat(ro.toString()).concat("'").concat(cValue).concat("'");
                default:
                    break;
            }
        } else if (USE_JDBC_DRIVER.toLowerCase().contains("mysql")) {
            switch (vt) {
                case DATE:
                    return cKey.concat(ro.toString()).concat("UNIX_TIMESTAMP('").concat(cValue).concat(" 00:00:00')");
                case TIME:
                    //throw new AppException(ResultCode.Failure, "暂不支持MySQL某段时间内查询,请确认日期后使用 ValueType.DATETIME 查询");
                case DATETIME:
                    return cKey.concat(ro.toString()).concat("UNIX_TIMESTAMP('").concat(cValue).concat("')");
                default:
                    break;
            }
        }
        return cKey.concat(" ").concat(ro.toString()).concat(" \"").concat(cValue).concat("\"");
    }

    private SQLQueryUtil addLikeCondition(LogicalOperators logicalOperators, String cKey, String cValue) {
        if (cValue.contains("%")) {
            conditionMap.put(logicalOperators.toString(), cKey.concat(" LIKE \"").concat(cValue).concat("\""));
        } else {
            conditionMap.put(logicalOperators.toString(), cKey.concat(" LIKE \"%").concat(cValue).concat("%\""));
        }
        return this;
    }

    private SQLQueryUtil addInCondition(LogicalOperators logicalOperators, String cKey, String cValue) {
        conditionMap.put(logicalOperators.toString(), cKey.concat(" IN ( ").concat(cValue).concat(" )"));
        return this;
    }

    private SQLQueryUtil addNotInCondition(LogicalOperators logicalOperators, String cKey, String cValue) {
        conditionMap.put(logicalOperators.toString(), cKey.concat(" NOT IN ( ").concat(cValue).concat(" )"));
        return this;
    }

    private SQLQueryUtil addOrderBy(String orderField, SortMethod sortMethod) {
        orderMap.put(orderField, sortMethod.toString());
        return this;
    }

    /**
     * 添加分组字段
     *
     * @param groupField
     * @return
     */
    public SQLQueryUtil addGroupBy(String groupField) {
        groupList.add(groupField);
        return this;
    }



    /**
     * 添加 AND查询条件
     *
     * @param cKey
     * @param relationalOperators
     * @param cValue
     * @param valueType
     * @return
     */
    public SQLQueryUtil addAndCondition(String cKey, RelationalOperators relationalOperators, String cValue, ValueType valueType) {
        return this.addCondition(LogicalOperators.AND, cKey, relationalOperators, cValue, valueType);
    }

    /**
     * 添加 OR查询条件
     *
     * @param cKey
     * @param relationalOperators
     * @param cValue
     * @param valueType
     * @return
     */
    public SQLQueryUtil addOrCondition(String cKey, RelationalOperators relationalOperators, String cValue, ValueType valueType) {
        return this.addCondition(LogicalOperators.OR, cKey, relationalOperators, cValue, valueType);
    }

    /**
     * 添加 AND LIKE 查询条件
     *
     * @param cKey
     * @param cValue
     * @return
     */
    public SQLQueryUtil addAndLikeCondition(String cKey, String cValue) {
        return this.addLikeCondition(LogicalOperators.AND, cKey, cValue);
    }

    /**
     * 添加 OR LIKE 查询条件
     *
     * @param cKey
     * @param cValue
     * @return
     */
    public SQLQueryUtil addOrLikeCondition(String cKey, String cValue) {
        return this.addLikeCondition(LogicalOperators.OR, cKey, cValue);
    }

    /**
     * 添加 AND IN 查询条件
     *
     * @param cKey
     * @param cValue
     * @return
     */
    public SQLQueryUtil addAndInCondition(String cKey, String cValue) {
        return this.addInCondition(LogicalOperators.AND, cKey, cValue);
    }

    /**
     * 添加 OR IN 查询条件
     *
     * @param cKey
     * @param cValue
     * @return
     */
    public SQLQueryUtil addOrInCondition(String cKey, String cValue) {
        return this.addInCondition(LogicalOperators.OR, cKey, cValue);
    }

    /**
     * 添加 AND NOT IN 查询条件
     *
     * @param cKey
     * @param cValue
     * @return
     */
    public SQLQueryUtil addAndNotInCondition(String cKey, String cValue) {
        return this.addNotInCondition(LogicalOperators.AND, cKey, cValue);
    }

    /**
     * 添加 OR NOT IN 查询条件
     *
     * @param cKey
     * @param cValue
     * @return
     */
    public SQLQueryUtil addOrNotInCondition(String cKey, String cValue) {
        return this.addNotInCondition(LogicalOperators.OR, cKey, cValue);
    }

    /**
     * 添加正向排序字段
     *
     * @param orderField
     * @return
     */
    public SQLQueryUtil addAscOrderBy(String orderField) {
        return this.addOrderBy(orderField, SortMethod.ASC);
    }

    /*
     * 添加逆向排序字段
     */
    public SQLQueryUtil addDescOrderBy(String orderField) {
        return this.addOrderBy(orderField, SortMethod.DESC);
    }

    /**
     * 清除待查表和视图
     *
     * @return
     */
    public SQLQueryUtil clearTable() {
        tableMap.clear();
        return this;
    }

    /**
     * 清除待查列
     *
     * @return
     */
    public SQLQueryUtil clearColumn() {
        columnMap.clear();
        return this;
    }

    /**
     * 清除查询条件
     *
     * @return
     */
    public SQLQueryUtil clearCondition() {
        conditionMap.clear();
        return this;
    }

    /**
     * 清除排序条件
     *
     * @return
     */
    public SQLQueryUtil clearOrder() {
        orderMap.clear();
        return this;
    }

    /**
     * 清除分组列
     *
     * @return
     */
    public SQLQueryUtil clearGroup() {
        groupList.clear();
        return this;
    }
}

 

分享到:
评论

相关推荐

    基于Springboot的实验报告系统源码数据库文档.zip

    基于Springboot的实验报告系统源码数据库文档.zip

    ERA5_Climate_Single_Month.txt

    GEE训练教程——Landsat5、8和Sentinel-2、DEM和各2哦想指数下载

    基于springboot智能健康饮食系统源码数据库文档.zip

    基于springboot智能健康饮食系统源码数据库文档.zip

    基于SpringBoot的校园服务系统源码数据库文档.zip

    基于SpringBoot的校园服务系统源码数据库文档.zip

    史上最全IXIA测试仪配置使用指导手册(含IxNetwork,图文并茂超详细!).zip

    内容概要: IXIA测试仪的基本配置.doc ixia测试仪基础使用示例.doc IxNetwork如何进行抓包回放-V1.0.pdf IxNetwork如何自定义报文-V2.0.pdf ixia构造ip分片方法.txt IxNetwork使用简介.pdf 适用人群:网络协议造包、打流相关的测试工程技术人员,想要学习的同学可以下载哈 使用场景:构造pcap包,打流 Ixia简介 IXIA使用的是Server-client模式,Server端在测试仪表的主机上,在开机后会随着主机内的操作系统的启动而自动启动,一般情况下不需要人为的手工启动。因此在通常不需要为主机配置专用的显示器和键盘。 client端包括两个测试软件: Ixia Explorer和ScriptMate。这两个软件一般安装在测试用计算机上,在仪表自带的主机中也有这两个软件。根据测试项目的不同来选择使用不同的软件。Ixia Explorer主要提供数据流的测试,针对设备的功能进行测试; ScriptMate提供各种性能测试窗口,针对设备的性能进行测试。 Auto:自动分配;

    基于Python+Django花卉商城系统源码数据库文档.zip

    基于Python+Django花卉商城系统源码数据库文档.zip

    Umi-OCR-main.zip

    Umi-OCR-main.zip

    微信小程序源码-促销抽奖.zip

    基于微信小程序开发的促销抽奖小工具源码,适用于初学者了解小程序开发过程以及简单抽奖工具的实现。

    Sen2_median.txt

    GEE训练教程——Landsat5、8和Sentinel-2、DEM和各2哦想指数下载

    springboot的概要介绍与分析

    以下是一个关于Spring Boot设计的资源描述及项目源码的简要概述: Spring Boot设计资源描述 Spring Boot是一个为基于Spring的应用提供快速开发工具的框架,其设计旨在简化Spring应用的初始搭建和开发过程。以下是一些关键资源: Spring Boot官方文档:详细阐述了Spring Boot的核心特性、自动配置原理、起步依赖、内嵌式服务器等关键概念。这是学习和掌握Spring Boot设计的首选资源。 在线教程与视频:各大在线教育平台提供了丰富的Spring Boot教程和视频课程,从基础入门到高级应用,帮助开发者全面了解和掌握Spring Boot设计。 书籍与电子资料:许多技术书籍和在线电子资料深入讲解了Spring Boot的设计原理、最佳实践和项目案例,为开发者提供了宝贵的学习资源。 项目源码示例 以下是一个简单的Spring Boot项目源码示例,用于演示Spring Boot的基本结构和自动配置功能: java // 引入Spring Boot依赖 @SpringBootApplication public class MySpri

    基于springboot美妆领域管理系统源码数据库文档.zip

    基于springboot美妆领域管理系统源码数据库文档.zip

    tables-3.7.0+gpl-cp37-cp37m-win_amd64.whl

    tables-3.7.0+gpl-cp37-cp37m-win_amd64.whl

    算法实现的概要介绍与分析

    算法是计算机科学的核心,它们在解决各种问题时发挥着关键作用。一个好的算法不仅可以提高程序的效率,还可以简化复杂的问题。下面我将通过一个具体的例子——快速排序算法(Quick Sort)——来展示算法的实现过程,包括资源描述和项目源码。 ### 快速排序算法简介 快速排序是一种高效的排序算法,采用分治法的思想。其基本步骤如下: 1. 从数列中挑出一个元素,称为“基准”(pivot)。 2. 重新排序数列,所有比基准值小的元素放到基准前面,所有比基准值大的元素放到基准后面(相同的数可以到任一边)。在这个分割结束之后,该基准就处于数列的中间位置。这个称为分割(partition)操作。 3. 递归地(recursive)把小于基准值的子数列和大于基准值的子数列排序。 ### 资源描述 快速排序算法因其高效性和简洁性,在实际应用中非常受欢迎。它的时间复杂度平均为 O(n log n),最坏情况下为 O(n^2),但这种情况很少发生。快速排序的空间复杂度为 O(log n),因为它使用了递归来实现。 快速排序的一个典型应用场景是在数据库系统中对大量数据进行排序。由于它的高效性,快速排序

    基于springboot农场投入品运营线上管理系统源码数据库文档.zip

    基于springboot农场投入品运营线上管理系统源码数据库文档.zip

    基于springboot个性化影院推荐系统源码数据库文档.zip

    基于springboot个性化影院推荐系统源码数据库文档.zip

    linux基础进阶笔记

    linux基础进阶笔记,配套视频:https://www.bilibili.com/list/474327672?sid=4493093&spm_id_from=333.999.0.0&desc=1

    微信自动抢红包动态库.zip程序资源学习资料参考

    小程序 微信自动抢红包动态库.zip程序资源学习资料参考

    iOS版微信抢红包插件(支持后台抢红包).zip

    小程序 iOS版微信抢红包插件(支持后台抢红包).zip

    经典-FPGA时序约束教程

    经典-FPGA时序约束教程

    基于springboot的智慧点餐系统源码数据库文档.zip

    基于springboot的智慧点餐系统源码数据库文档.zip

Global site tag (gtag.js) - Google Analytics