org.xutils.db.sqlite.WhereBuilder

Posted 2021-04-30 荆花知了窝

package org.xutils.db.sqlite;

import android.text.TextUtils;

import org.xutils.db.converter.ColumnConverterFactory;
import org.xutils.db.table.ColumnUtils;

import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

/**
 * @author 注释者：王教成
 * @version 注释版：1.0.0
 * 选择语句生成器
 */
public class WhereBuilder {
    private final List<String> whereItems;//声明字符串列表作为where项目
    private WhereBuilder() {
        this.whereItems = new ArrayList<String>();//创建where项目字符串列表
    }//构造器

    /**
     * 创建新实例
     * @return 返回where语句生成器
     */
    public static WhereBuilder b() {
        return new WhereBuilder();
    }
    /**
     * 创建新实例
     * @param columnName 列名
     * @param op 运算符：“=”、“LIKE”、“IN”、“BETWEEN”等等
     * @param value 值
     * @return 返回where语句生成器
     */
    public static WhereBuilder b(String columnName, String op, Object value) {
        WhereBuilder result = new WhereBuilder();
        result.appendCondition(null, columnName, op, value);//添加条件
        return result;
    }

    /**
     * 添加AND条件
     * @param columnName 列名
     * @param op 运算符：“=”、“LIKE”、“IN”、“BETWEEN”等等
     * @param value 值
     * @return 返回where语句生成器
     */
    public WhereBuilder and(String columnName, String op, Object value) {
        appendCondition(whereItems.size() == 0 ? null : "AND", columnName, op, value);//添加条件
        return this;
    }
    /**
     * 添加AND条件
     * @param where expr（“【AND】（”+ where.toString（）+“）”）
     * @return 返回where语句生成器
     */
    public WhereBuilder and(WhereBuilder where) {
        String condition = whereItems.size() == 0 ? " " : "AND ";//字符串列表尺寸为0则空字符串，否则“AND ”
        return expr(condition + "(" + where.toString() + ")");//返回表达式方法结果where语句生成器
    }

    /**
     * 添加OR条件
     * @param columnName
     * @param op 运算符：“=”、“LIKE”、“IN”、“BETWEEN”等等
     * @param value 值
     * @return 返回where语句生成器
     */
    public WhereBuilder or(String columnName, String op, Object value) {
        appendCondition(whereItems.size() == 0 ? null : "OR", columnName, op, value);//添加条件
        return this;
    }
    /**
     * 添加OR条件
     * @param where expr（“【OR】（”+ where.toString（）+“）”）
     * @return 返回where语句生成器
     */
    public WhereBuilder or(WhereBuilder where) {
        String condition = whereItems.size() == 0 ? " " : "OR ";//字符串列表尺寸为0则空字符串，否则“OR ”
        return expr(condition + "(" + where.toString() + ")");//返回表达式方法结果where语句生成器
    }

    /**
     * 表达式方法
     * @param expr 表达式字符串
     * @return 返回where语句生成器
     */
    public WhereBuilder expr(String expr) {
        whereItems.add(" " + expr);//字符串列表添加表达式
        return this;
    }

    /**
     * 获取where选项字符串列表大小
     * @return 返回where选项字符串列表大小
     */
    public int getWhereItemSize() {
        return whereItems.size();
    }

    /**
     * 重写Object的toString方法
     * @return 返回where选项字符串
     */
    @Override
    public String toString() {
        if (whereItems.size() == 0) {
            return "";//如果字符串列表容量0返回空字符串
        }
        StringBuilder sb = new StringBuilder();//创建非线程安全字符串变量
        for (String item : whereItems) {
            sb.append(item);//迭代添加where选项
        }
        return sb.toString();//字符串变量转字符串常量
    }

    /**
     * 添加条件
     * @param conj 连接词
     * @param columnName 列名
     * @param op 运算符
     * @param value 值
     */
    private void appendCondition(String conj, String columnName, String op, Object value) {
        StringBuilder builder = new StringBuilder();//创建非线程安全字符串变量

        if (whereItems.size() > 0) {
            builder.append(" ");//如果where项目字符串列表大于0，添加空格
        }

        if (!TextUtils.isEmpty(conj)) {
            builder.append(conj).append(" ");//如果连接词非空，添加连接词再添加空格
        }//添加连接词代码块

        builder.append("\"").append(columnName).append("\"");//添加列名代码块

        if ("!=".equals(op)) {
            op = "<>";//如果运算符是“!=”，运算符赋值“<>”
        } else if ("==".equals(op)) {
            op = "=";//如果运算符是“==”，运算符赋值“=”
        }//转换运算符代码块

        //添加运算符和值代码块
        if (value == null) {
            if ("=".equals(op)) {
                builder.append(" IS NULL");//如果值为空，运算符是“=”，添加is null
            } else if ("<>".equals(op)) {
                builder.append(" IS NOT NULL");//如果值为空，运算符是“<>”，添加is not null
            } else {
                builder.append(" ").append(op).append(" NULL");//如果值为空，运算符不是“=”和“<>”，添加null
            }
        } else {
            builder.append(" ").append(op).append(" ");//如果值非空，添加运算符

            if ("IN".equalsIgnoreCase(op)) {
                Iterable<?> items = null;//如果运算符是“IN”，声明迭代器
                if (value instanceof Iterable) {
                    items = (Iterable<?>) value;//如果值是迭代器，强转赋值迭代器
                } else if (value.getClass().isArray()) {
                    int len = Array.getLength(value);//如果值是数组，获取数组长度
                    List<Object> arrayList = new ArrayList<Object>(len);//以长度创建数组列表
                    for (int i = 0; i < len; i++) {
                        arrayList.add(Array.get(value, i));//迭代添加进数组列表
                    }
                    items = arrayList;//数组列表赋值迭代器
                }
                if (items != null) {
                    StringBuilder inSb = new StringBuilder("(");//如果迭代器非空，创建非线程安全子字符串变量
                    for (Object item : items) {
                        Object itemColValue = ColumnUtils.convert2DbValueIfNeeded(item);//如果需要迭代转化为数据库值
                        if (ColumnDbType.TEXT.equals(ColumnConverterFactory.getDbColumnType(itemColValue.getClass()))) {
                            String valueStr = itemColValue.toString();//如果数据库值是TEXT，转化为值字符串
                            if (valueStr.indexOf('\'') != -1) {//转换单引用
                                valueStr = valueStr.replace("'", "''");//如果值字符串中单引号索引不是-1，替换符号
                            }
                            inSb.append("'").append(valueStr).append("'");//添加值字符串
                        } else {
                            inSb.append(itemColValue);//添加数据库值
                        }
                        inSb.append(",");//添加逗号
                    }
                    inSb.deleteCharAt(inSb.length() - 1);//迭代完成删除最后一个逗号
                    inSb.append(")");//添加右括号
                    builder.append(inSb.toString());//子字符串变量添加进字符串变量
                } else {
                    throw new IllegalArgumentException("value must be an Array or an Iterable.");//迭代器为空，抛出非法参数异常
                }
            } else if ("BETWEEN".equalsIgnoreCase(op)) {
                Iterable<?> items = null;//如果运算符是“BETWEEN”，声明迭代器
                if (value instanceof Iterable) {
                    items = (Iterable<?>) value;//如果值是迭代器，强转赋值迭代器
                } else if (value.getClass().isArray()) {
                    int len = Array.getLength(value);//如果值是数组，获取数组长度
                    List<Object> arrayList = new ArrayList<Object>(len);//以长度创建数组列表
                    for (int i = 0; i < len; i++) {
                        arrayList.add(Array.get(value, i));//迭代添加进数组列表
                    }
                    items = arrayList;//数组列表赋值迭代器
                }
                if (items != null) {
                    Iterator<?> iterator = items.iterator();//如果迭代器非空，创建迭代器
                    if (!iterator.hasNext())
                        throw new IllegalArgumentException("value must have tow items.");//如果还有下一项，抛出非法参数异常
                    Object start = iterator.next();//将迭代项赋给开始对象
                    if (!iterator.hasNext())
                        throw new IllegalArgumentException("value must have tow items.");//如果还有下一项，抛出非法参数异常
                    Object end = iterator.next();//将迭代项赋予结束对象

                    Object startColValue = ColumnUtils.convert2DbValueIfNeeded(start);//开始对象转为开始列数据库值
                    Object endColValue = ColumnUtils.convert2DbValueIfNeeded(end);//结束对象转为结束列数据库值

                    if (ColumnDbType.TEXT.equals(ColumnConverterFactory.getDbColumnType(startColValue.getClass()))) {
                        String startStr = startColValue.toString();//如果列数据库类型是TEXT，转换为值字符串
                        if (startStr.indexOf('\'') != -1) {//转换单引用
                            startStr = startStr.replace("'", "''");//如果开始值字符串中单引号索引不是-1，替换符号
                        }
                        String endStr = endColValue.toString();
                        if (endStr.indexOf('\'') != -1) {//转换单引用
                            endStr = endStr.replace("'", "''");//如果结束值字符串中单引号索引不是-1，替换符号
                        }
                        builder.append("'").append(startStr).append("'");//添加开始字符串
                        builder.append(" AND ");//添加“AND”
                        builder.append("'").append(endStr).append("'");//添加结束字符串
                    } else {
                        builder.append(startColValue);//如果类数据库类型非TEXT，添加开始列数据库值
                        builder.append(" AND ");//添加“AND”
                        builder.append(endColValue);//添加结束列数据库值
                    }
                } else {
                    throw new IllegalArgumentException("value must be an Array or an Iterable.");//如果迭代器为空，抛出非法参数异常
                }
            } else {
                value = ColumnUtils.convert2DbValueIfNeeded(value);//如果运算符不是in和between，值转化为数据库值
                if (ColumnDbType.TEXT.equals(ColumnConverterFactory.getDbColumnType(value.getClass()))) {
                    String valueStr = value.toString();//如果类数据库类型，值转换为值字符串
                    if (valueStr.indexOf('\'') != -1) {//转换单引用
                        valueStr = valueStr.replace("'", "''");//如果值字符串中单引号索引不是-1，替换符号
                    }
                    builder.append("'").append(valueStr).append("'");//添加值字符串
                } else {
                    builder.append(value);//否则直接添加值
                }
            }
        }
        whereItems.add(builder.toString());//字符串变量转为字符串常量添加进where选项字符串列表
    }
}