org.xutils.db.sqlite.SqlInfoBuilder

Posted 2021-04-30 荆花知了窝

package org.xutils.db.sqlite;

import org.xutils.common.util.KeyValue;
import org.xutils.db.table.ColumnEntity;
import org.xutils.db.table.TableEntity;
import org.xutils.ex.DbException;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.concurrent.ConcurrentHashMap;

/**
 * @author 注释者：王教成
 * @version 注释版：1.0.0
 * 结构化查询语言信息生成器，生成“insert”、“replace”、“update”、“delete”和“create”SQL语句
 */
public final class SqlInfoBuilder {
    private static final ConcurrentHashMap<TableEntity<?>, String> INSERT_SQL_CACHE = new ConcurrentHashMap<TableEntity<?>, String>();//创建线程安全HashMap：插入SQL缓存
    private static final ConcurrentHashMap<TableEntity<?>, String> REPLACE_SQL_CACHE = new ConcurrentHashMap<TableEntity<?>, String>();//创建线程安全HashMap：替换SQL缓存
    private SqlInfoBuilder() {
    }//构造器

    //****************************insert sql****************************
    /**
     * 生成插入SqlInfo
     * @param table 数据表实体
     * @param entity 实体对象
     * @return 返回插入SqlInfo
     * @throws DbException 抛出数据库异常
     */
    public static SqlInfo buildInsertSqlInfo(TableEntity<?> table, Object entity) throws DbException {

        List<KeyValue> keyValueList = entity2KeyValueList(table, entity);//类型对象转键值对列表
        if (keyValueList.size() == 0) return null;//如果列表尺寸0返回null

        SqlInfo result = new SqlInfo();//创建SqlInfo对象
        String sql = INSERT_SQL_CACHE.get(table);//根据数据表实体从插入SQL缓存中获取SQL字符串
        if (sql == null) {
            StringBuilder builder = new StringBuilder();//如果SQL字符串为空，创建非线程安全字符串变量
            builder.append("INSERT INTO ");//添加插入命令
            builder.append("\"").append(table.getName()).append("\"");//添加数据表名称
            builder.append(" (");//添加左括号
            for (KeyValue kv : keyValueList) {
                builder.append("\"").append(kv.key).append("\"").append(',');//迭代键值列表，添加键值的键
            }
            builder.deleteCharAt(builder.length() - 1);//迭代完成删除最后一个字符
            builder.append(") VALUES (");

            int length = keyValueList.size();//获取键值列表尺寸
            for (int i = 0; i < length; i++) {
                builder.append("?,");//迭代添加
            }
            builder.deleteCharAt(builder.length() - 1);//迭代完成删除最后一个字符
            builder.append(")");//添加右括号

            sql = builder.toString();//字符串变量转字符串常量
            result.setSql(sql);//字符串常量作为SqlInfo
            result.addBindArgs(keyValueList);//键值列表加入SqlInfo对象
            INSERT_SQL_CACHE.put(table, sql);//放入插入SQL缓存
        } else {
            result.setSql(sql);//如果SQL字符串非空，作为SqlInfo参数
            result.addBindArgs(keyValueList);//键值列表加入SqlInfo对象
        }

        return result;
    }

    //****************************replace sql****************************
    /**
     * 生成替换SqlInfo
     * @param table 数据表实体
     * @param entity 实体类型
     * @return 返回替换SqlInfo
     * @throws DbException 抛出数据库异常
     */
    public static SqlInfo buildReplaceSqlInfo(TableEntity<?> table, Object entity) throws DbException {

        List<KeyValue> keyValueList = entity2KeyValueList(table, entity);//类型对象转键值对列表
        if (keyValueList.size() == 0) return null;//如果列表尺寸0返回null

        SqlInfo result = new SqlInfo();//创建SqlInfo对象
        String sql = REPLACE_SQL_CACHE.get(table);//根据数据表实体从替换SQL缓存中获取SQL字符串
        if (sql == null) {
            StringBuilder builder = new StringBuilder();//如果SQL字符串为空，创建非线程安全字符串变量
            builder.append("REPLACE INTO ");//添加替换命令
            builder.append("\"").append(table.getName()).append("\"");//添加数据表名称
            builder.append(" (");//添加左括号
            for (KeyValue kv : keyValueList) {
                builder.append("\"").append(kv.key).append("\"").append(',');//迭代键值列表，添加键值的键
            }
            builder.deleteCharAt(builder.length() - 1);//迭代完成删除最后一个字符
            builder.append(") VALUES (");

            int length = keyValueList.size();//获取键值列表尺寸
            for (int i = 0; i < length; i++) {
                builder.append("?,");//迭代添加
            }
            builder.deleteCharAt(builder.length() - 1);//迭代完成删除最后一个字符
            builder.append(")");//添加右括号

            sql = builder.toString();//字符串变量转字符串常量
            result.setSql(sql);//字符串常量作为SqlInfo
            result.addBindArgs(keyValueList);//键值列表加入SqlInfo对象
            REPLACE_SQL_CACHE.put(table, sql);//放入替换SQL缓存
        } else {
            result.setSql(sql);//如果SQL字符串非空，作为SqlInfo参数
            result.addBindArgs(keyValueList);//键值列表加入SqlInfo对象
        }

        return result;
    }

    //****************************delete sql****************************
    /**
     * 生成删除SqlInfo
     * @param table 数据表实体
     * @param entity 实体类型
     * @return 返回删除SqlInfo
     * @throws DbException 抛出数据库异常
     */
    public static SqlInfo buildDeleteSqlInfo(TableEntity<?> table, Object entity) throws DbException {
        SqlInfo result = new SqlInfo();//创建SqlInfo对象

        ColumnEntity id = table.getId();//从数据表实体获取列实体
        Object idValue = id.getColumnValue(entity);//用实体类型作为参数从列实体获取列实体值

        if (idValue == null) {
            throw new DbException("this entity[" + table.getEntityType() + "]'s id value is null");//如果列实体值为空，抛出数据库异常
        }
        StringBuilder builder = new StringBuilder("DELETE FROM ");//创建非线程安全字符串变量
        builder.append("\"").append(table.getName()).append("\"");//添加数据表名称
        builder.append(" WHERE ").append(WhereBuilder.b(id.getName(), "=", idValue));//添加where语句

        result.setSql(builder.toString());//字符串变量转字符串常量，作为SqlInfo对象参数
        return result;
    }
    /**
     * 生成删除SqlInfo
     * @param table 数据表实体
     * @param idValue 列实体值
     * @return 返回删除SqlInfo
     * @throws DbException 抛出数据库异常
     */
    public static SqlInfo buildDeleteSqlInfoById(TableEntity<?> table, Object idValue) throws DbException {
        SqlInfo result = new SqlInfo();//创建SqlInfo对象

        ColumnEntity id = table.getId();//从数据表实体获取列实体

        if (idValue == null) {
            throw new DbException("this entity[" + table.getEntityType() + "]'s id value is null");//如果列实体值为空，抛出数据库异常
        }
        StringBuilder builder = new StringBuilder("DELETE FROM ");//创建非线程安全字符串变量
        builder.append("\"").append(table.getName()).append("\"");//添加数据表名称
        builder.append(" WHERE ").append(WhereBuilder.b(id.getName(), "=", idValue));//添加where语句

        result.setSql(builder.toString());//字符串变量转字符串常量，作为SqlInfo对象参数
        return result;
    }
    /**
     * 生成删除SqlInfo
     * @param table 数据表实体
     * @param whereBuilder where语句生成器
     * @return 返回删除SqlInfo
     * @throws DbException 抛出数据库异常
     */
    public static SqlInfo buildDeleteSqlInfo(TableEntity<?> table, WhereBuilder whereBuilder) throws DbException {
        StringBuilder builder = new StringBuilder("DELETE FROM ");//创建非线程安全字符串变量
        builder.append("\"").append(table.getName()).append("\"");//添加数据表名称

        if (whereBuilder != null && whereBuilder.getWhereItemSize() > 0) {
            builder.append(" WHERE ").append(whereBuilder.toString());//如果where生成器非空且尺寸大于0，添加where语句
        }

        return new SqlInfo(builder.toString());//字符串变量转字符串常量，作为SqlInfo对象参数
    }

    //****************************update sql****************************
    /**
     * 生成更新SqlInfo
     * @param table 数据表实体
     * @param entity 实体对象
     * @param updateColumnNames 更新列名字符串组
     * @return 返回更新SqlInfo
     * @throws DbException 抛出数据库异常
     */
    public static SqlInfo buildUpdateSqlInfo(TableEntity<?> table, Object entity, String... updateColumnNames) throws DbException {

        List<KeyValue> keyValueList = entity2KeyValueList(table, entity);//实体对象转键值列表
        if (keyValueList.size() == 0) return null;//如果键值列表容量0返回null

        HashSet<String> updateColumnNameSet = null;//声明更新列名HashSet集合
        if (updateColumnNames != null && updateColumnNames.length > 0) {
            updateColumnNameSet = new HashSet<String>(updateColumnNames.length);//如果更新列名字符串组非空且尺寸大于0，以尺寸创建更新列名字符串集合
            Collections.addAll(updateColumnNameSet, updateColumnNames);//添加所有更新列名到更新列名集合
        }

        ColumnEntity id = table.getId();//从数据表实体获取列实体
        Object idValue = id.getColumnValue(entity);//以实体对象通过列实体获取列值

        if (idValue == null) {
            throw new DbException("this entity[" + table.getEntityType() + "]'s id value is null");//如果列值为null，抛出数据库异常
        }

        SqlInfo result = new SqlInfo();//创建SqlInfo对象
        StringBuilder builder = new StringBuilder("UPDATE ");//创建非线程安全字符串变量
        builder.append("\"").append(table.getName()).append("\"");//添加数据表名称
        builder.append(" SET ");//添加SET字符串
        for (KeyValue kv : keyValueList) {
            if (updateColumnNameSet == null || updateColumnNameSet.contains(kv.key)) {
                builder.append("\"").append(kv.key).append("\"").append("=?,");//迭代键值列表，如果更新列名集合非空且包含键值的key，添加键值的key
                result.addBindArg(kv);//键值加入SqlInfo
            }
        }
        builder.deleteCharAt(builder.length() - 1);//迭代完成删除最后一个字符
        builder.append(" WHERE ").append(WhereBuilder.b(id.getName(), "=", idValue));//添加where语句

        result.setSql(builder.toString());//字符串变量转字符串常量，作为SqlInfo对象参数
        return result;
    }
    /**
     * 生成更新SqlInfo
     * @param table 数据表实体
     * @param whereBuilder where语句生成器
     * @param nameValuePairs 名称值对
     * @return 返回更新SqlInfo
     * @throws DbException 抛出数据库异常
     */
    public static SqlInfo buildUpdateSqlInfo(TableEntity<?> table, WhereBuilder whereBuilder, KeyValue... nameValuePairs) throws DbException {

        if (nameValuePairs == null || nameValuePairs.length == 0) return null;//如果名称值对为空或者长度为0，返回null

        SqlInfo result = new SqlInfo();//创建SqlInfo
        StringBuilder builder = new StringBuilder("UPDATE ");//创建非线程安全字符串变量
        builder.append("\"").append(table.getName()).append("\"");//添加数据表名称
        builder.append(" SET ");//添加“SET”
        for (KeyValue kv : nameValuePairs) {
            builder.append("\"").append(kv.key).append("\"").append("=?,");//迭代名称值对，添加键值的key
            result.addBindArg(kv);//键值加入SqlInfo
        }
        builder.deleteCharAt(builder.length() - 1);//迭代完成删除最后一个字符
        if (whereBuilder != null && whereBuilder.getWhereItemSize() > 0) {
            builder.append(" WHERE ").append(whereBuilder.toString());//添加where语句
        }

        result.setSql(builder.toString());//字符串变量转字符串常量，作为SqlInfo对象参数
        return result;
    }

    //****************************others****************************
    /**
     * 生成创建数据表SqlInfo
     * @param table 表实体
     * @return 返回创建数据表SqlInfo
     * @throws DbException 抛出数据库异常
     */
    public static SqlInfo buildCreateTableSqlInfo(TableEntity<?> table) throws DbException {
        ColumnEntity id = table.getId();//获取列实体

        StringBuilder builder = new StringBuilder();//创建非线程安全字符串变量
        builder.append("CREATE TABLE IF NOT EXISTS ");//如果不存在，创建表格
        builder.append("\"").append(table.getName()).append("\"");//表格名称
        builder.append(" ( ");//添加左括号

        if (id.isAutoId()) {
            builder.append("\"").append(id.getName()).append("\"").append(" INTEGER PRIMARY KEY AUTOINCREMENT, ");//如果自动ID，获取列实体名称，设置主键自增长
        } else {
            builder.append("\"").append(id.getName()).append("\"").append(id.getColumnDbType()).append(" PRIMARY KEY, ");//如果不是自动ID，获取列实体名称，获取列数据库类型设置主键
        }

        Collection<ColumnEntity> columns = table.getColumnMap().values();//表实体获取列Map的值列实体
        for (ColumnEntity column : columns) {
            if (column.isId()) continue;//迭代列实体，如果列实体是列实体，进行下一次循环
            builder.append("\"").append(column.getName()).append("\"");//添加列名称
            builder.append(' ').append(column.getColumnDbType());//添加列数据库类型
            builder.append(' ').append(column.getProperty());//添加列属性
            builder.append(',');//逗号间隔
        }

        builder.deleteCharAt(builder.length() - 1);//循环完成后删除最后一个逗号
        builder.append(" )");//添加右括号
        return new SqlInfo(builder.toString());//字符串变量转字符串常量作为SqlInfo参数
    }

    /**
     * 实体对象转键值列表
     * @param table 表实体
     * @param entity 实体对象
     * @return 返回键值列表
     */
    public static List<KeyValue> entity2KeyValueList(TableEntity<?> table, Object entity) {
        Collection<ColumnEntity> columns = table.getColumnMap().values();//数据表获取列Map的值集合，赋值列实体集合
        List<KeyValue> keyValueList = new ArrayList<KeyValue>(columns.size());//创建列集合大小的键值列表
        for (ColumnEntity column : columns) {
            KeyValue kv = column2KeyValue(entity, column);//迭代列实体，列实体转换键值
            if (kv != null) {
                keyValueList.add(kv);//如果键值非空，加入键值列表
            }
        }
        return keyValueList;
    }
    /**
     * 列转换为键值
     * @param entity 实体对象
     * @param column 列实体
     * @return 返回键值
     */
    private static KeyValue column2KeyValue(Object entity, ColumnEntity column) {
        if (column.isAutoId()) {
            return null;//如果列实体是自动ID，返回null
        }
        String key = column.getName();//获取列名赋值key
        Object value = column.getFieldValue(entity);//列实体从实体对象获取属性值赋值value
        return new KeyValue(key, value);//创建键值
    }
}