com.webapp.mybatis.helper.Cnds Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of utils-mybatis Show documentation
The newest version!
package com.webapp.mybatis.helper;

import java.text.DateFormat;
import java.util.Arrays;
import java.util.Date;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import java.util.SortedMap;
import java.util.TreeMap;
import java.util.concurrent.atomic.AtomicInteger;

import org.apache.commons.lang3.StringUtils;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.webapp.mybatis.helper.SqlHelper.AndOr;
import com.webapp.mybatis.helper.SqlHelper.Keys;


/**
 * where
 */
public final class Cnds {

//	private static final Logger logger = LoggerFactory.getLogger(Where.class);

	public enum Order {
		DESC, ASC;
	}

	public enum Op{
		EQ("="),
		NEQ("!="),
		GT(">"),
		GTE(">="),
		LT("<"),
		LTE("<="),
		LIKE("LIKE"),
		NLike("NOT LIKE"),
		IN("IN"),
		NIN("NOT IN"),
		ISNULL("IS NULL"),
		NISNULL("NOT IS NULL"),
		BETWEEN("BETWEEN");

		private String op;
		Op(String op){
			this.op = op;
		}
		public String toString() {
			return this.op.toString();
		}
		public static Op of(String op){
			List ops = Arrays.asList(values());
			for(Op ofOp : ops){
				if(ofOp.op.equals(op.toUpperCase())) return ofOp;
			}
			return null;
		}
	}

	protected static final String PARAM_NAME = "tp";
	private SortedMap tp = new TreeMap<>();
//	public SortedMap getParams() {
//		return tp;
//	}
	private StringBuffer where = new StringBuffer();
	private StringBuffer orderLimit = new StringBuffer();
	private static DateFormat df = DateFormat.getDateTimeInstance();
	private Cnds() {}
	private Cnds(String where) {
		this.where.append(where);
	}

	public static Cnds of() {
		return new Cnds();
	}
	public static Cnds of(String name, Object val) {
		Cnds w = of();
		return w.addAnd(SqlHelper.where(name, Op.EQ), name, val);
	}
	public static Cnds of(String name, Op op, Object ...vals) {
		Cnds w = of();
		return w.addAnd(SqlHelper.all(name, op, vals.length), name, vals);
	}
	public static  Cnds of(T model) {
		Cnds w = of();
		JSONObject json = JSON.parseObject(JSON.toJSONString(model));

		json.forEach((key, val)->{
			w.addAnd(SqlHelper.where(key, Op.EQ), key, val);
		});
		return w;
	}

	private String storeAndReplace(String cnd, String name, Object... vals) {
		for(Object val : vals){
			String unqiName = name + "_" + this.tp.size();
			this.tp.put(unqiName, val);
			cnd = cnd.replaceFirst(SqlHelper.replace(name), SqlHelper.placeholder(PARAM_NAME + "." + unqiName));
		}
		return cnd;
	}
	private Cnds addAnd(String cnd){
		return addAnd(cnd, null);
	}

	private Cnds addAnd(String cnd, String name, Object... vals){
		if(StringUtils.isNotEmpty(cnd)){
			if(StringUtils.isNoneEmpty(name)) cnd = storeAndReplace(cnd, name, vals);
			where.append(String.format(" %1$s %2$s", AndOr.AND.name(), cnd));
		}
		return this;
	}

	private Cnds addOr(String cnd){
		return addOr(cnd, null);
	}
	private Cnds addOr(String cnd, String name, Object... vals){
		if(StringUtils.isNotEmpty(cnd)){
			if(StringUtils.isNoneEmpty(name)) cnd = storeAndReplace(cnd, name, vals);
			where.append(String.format(" %1$s %2$s", AndOr.OR.name(), cnd));
		}
		return this;
	}

	public Cnds and(String name, Op op, Object ...vals){
		return addAnd(SqlHelper.all(name, op, vals.length), name, vals);
	}
	public Cnds andBetween(String name, Object min, Object max){
		return addAnd(SqlHelper.between(name), name, min, max);
	}
	public Cnds andEq(String name, Object val){
		return addAnd(SqlHelper.where(name, Op.EQ), name, val);
	}
	public Cnds andNotEq(String name, Object val){
		return addAnd(SqlHelper.where(name, Op.NEQ), name, val);
	}
	public Cnds andGT(String name, Object val){
		return addAnd(SqlHelper.where(name, Op.GT), name, val);
	}
	public Cnds andGTE(String name, Object val){
		return addAnd(SqlHelper.where(name, Op.GTE), name, val);
	}
	public Cnds andLT(String name, Object val){
		return addAnd(SqlHelper.where(name, Op.LT), name, val);
	}
	public Cnds andLTE(String name, Object val){
		return addAnd(SqlHelper.where(name, Op.LTE), name, val);
	}

	public Cnds andIn(String name, Object ...vals){
		return addAnd(SqlHelper.in(name, Op.IN, vals.length), name, vals);
	}
	public Cnds andNotIn(String name, Object ...vals){
		return addAnd(SqlHelper.in(name, Op.NIN, vals.length), name, vals);
	}
	public Cnds andIsNull(String name){
		return addAnd(SqlHelper.whereAlone(name, Op.ISNULL));
	}
	public Cnds andIsNotNull(String name){
		return addAnd(SqlHelper.whereAlone(name, Op.NISNULL));
	}

	public Cnds andLike(String name, String val){
		return addAnd(SqlHelper.like(name, Op.LIKE), name, val);
	}
	public Cnds andNotLike(String name, String val){
		return addAnd(SqlHelper.like(name, Op.NLike), name, val);
	}


	public Cnds or(String name, Op op, Object ...vals){
		return addOr(SqlHelper.all(name, op, vals.length), name, vals);
	}
	public Cnds orBetween(String name, Object min, Object max){
		return addOr(SqlHelper.between(name), name, min, max);
	}
	public Cnds orEq(String name, Object val){
		return addOr(SqlHelper.where(name, Op.EQ), name, val);
	}
	public Cnds orNotEq(String name, Object val){
		return addOr(SqlHelper.where(name, Op.NEQ), name, val);
	}
	public Cnds orGT(String name, Object val){
		return addOr(SqlHelper.where(name, Op.GT), name, val);
	}
	public Cnds orGTE(String name, Object val){
		return addOr(SqlHelper.where(name, Op.GTE), name, val);
	}
	public Cnds orLT(String name, Object val){
		return addOr(SqlHelper.where(name, Op.LT), name, val);
	}
	public Cnds orLTE(String name, Object val){
		return addOr(SqlHelper.where(name, Op.LTE), name, val);
	}

	public Cnds orIn(String name, Object ...vals){
		return addOr(SqlHelper.in(name, Op.IN, vals.length), name, vals);
	}
	public Cnds orNotIn(String name, Object ...vals){
		return addOr(SqlHelper.in(name, Op.NIN, vals.length), name, vals);
	}
	public Cnds orIsNull(String name){
		return addOr(SqlHelper.whereAlone(name, Op.ISNULL));
	}
	public Cnds orIsNotNull(String name){
		return addOr(SqlHelper.whereAlone(name, Op.NISNULL));
	}

	public Cnds orLike(String name, String val){
		return addOr(SqlHelper.like(name, Op.LIKE), name, val);
	}
	public Cnds orNotLike(String name, String val){
		return addOr(SqlHelper.like(name, Op.NLike), name, val);
	}


	/* sql wrap */
	private Cnds addWhere(Cnds wrap){
		String wrapWhere = wrap.where.toString();
		SortedMap wrapParam = wrap.tp;

		int count = tp.size();
		AtomicInteger index = new AtomicInteger();
		Iterator keys = wrapParam.keySet().iterator();
		for(;keys.hasNext();){
			String key = keys.next();
			String tar = index.toString();
			String replace = String.valueOf(index.getAndIncrement() + count);

			tp.put(key.replace(tar, replace), wrapParam.get(key));
			wrapWhere = wrapWhere.replace(tar, replace);
		}
		wrap.where = new StringBuffer(wrapWhere);
		return wrap;
	}
	private Cnds addWrap(AndOr andOr, Cnds wrap){
		String wrapSql = addWhere(wrap).toBaseSql();
		if(StringUtils.isNotEmpty(wrapSql))
			where.append(String.format(" %1$s (%2$s)", andOr.name(), wrapSql));
		return this;
	}
	public Cnds andWrap(Cnds wrap){
		return addWrap(AndOr.AND, wrap);
	}
	public Cnds orWrap(Cnds wrap){
		return addWrap(AndOr.OR, wrap);
	}

	/* sql order and limit */
	private Cnds addOrderLimit(String cnd){
		if(orderLimit.length() > 0 && cnd.contains(Keys.ORDER.toString())){
			orderLimit.append(", " + cnd.replaceFirst(Keys.ORDER.toString(), "").trim());
		}else {
			orderLimit.append(" " + cnd);
		}

		return this;
	}
	public Cnds order(String ...name){
		return addOrderLimit(SqlHelper.orderBy(Order.ASC, name));
	}
	public Cnds order(Order order, String ...name){
		return addOrderLimit(SqlHelper.orderBy(order, name));
	}
	public Cnds asc(String ...name){
		return addOrderLimit(SqlHelper.orderBy(Order.ASC, name));
	}
	public Cnds desc(String ...name){
		return addOrderLimit(SqlHelper.orderBy(Order.DESC, name));
	}

	public Cnds limit(int count){
		return addOrderLimit(SqlHelper.limit(0, count));
	}
	public Cnds limit(int index, int count){
		return addOrderLimit(SqlHelper.limit(index, count));
	}

	/* sql convert */
	private String toBaseSql() {
		String sql = where.toString().trim();
		if(StringUtils.isNotEmpty(sql)){
			if(sql.startsWith(AndOr.AND.toString())){
				sql = sql.replaceFirst(AndOr.AND.toString(), "").trim();
			}else if(sql.startsWith(AndOr.OR.toString())){
				sql = sql.replaceFirst(AndOr.OR.toString(), "").trim();
			}
			return String.format("WHERE %1$s %2$s", sql, orderLimit.toString().trim());
		}
		return orderLimit.toString().trim();
	}
	private static String fmt(Object val){
		String kv = "";
		if(val instanceof Date){
			kv += String.format("'%s'", df.format(val));
		}else if(val instanceof String){
			kv += String.format("'%s'", val);
		}else {
			kv += String.format("%s", val);
		}
		return kv;
	}
	/**
	 * Call when using Mybatis
	 */
	public String toSql() {
		return toBaseSql();
	}

	/**
	 * log use as debug or info
	 */
	public String toPlainSql(boolean showVal) {
		String sql = toBaseSql();
		Set keys = tp.keySet();
		for (String key : keys) {
			String val = fmt(tp.get(key));
			sql = sql.replace(String.format("#{%1$s.%2$s}", PARAM_NAME, key), showVal ? val : "?");
		}
		return sql;
	}

	public String toString(){
		return toSql();
	}
}