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

tk.mybatis.mapper.weekend.SqlCriteriaHelper Maven / Gradle / Ivy

package tk.mybatis.mapper.weekend;

import tk.mybatis.mapper.util.Sqls;
import tk.mybatis.mapper.weekend.reflection.Reflections;

import java.util.Optional;

/**
 * sql 条件语句
 *
 * @author Cheng.Wei
 * @date 2019-04-15 10:26
 */
public class SqlCriteriaHelper implements tk.mybatis.mapper.entity.SqlsCriteria {
    private Sqls.Criteria criteria;

    private SqlCriteriaHelper() {
        this.criteria = new Sqls.Criteria();
    }

    public static  SqlCriteriaHelper custom(Class clazz) {
        return new SqlCriteriaHelper();
    }

    /**
     * AND column IS NULL
     *
     * @param fn
     * @return
     */
    public SqlCriteriaHelper andIsNull(Fn fn) {
        this.criteria.getCriterions().add(new Sqls.Criterion(Reflections.fnToFieldName(fn), "is null", "and"));
        return this;
    }


    /**
     * AND column IS NOT NULL
     *
     * @param fn
     * @return
     */
    public SqlCriteriaHelper andIsNotNull(Fn fn) {
        this.criteria.getCriterions().add(new Sqls.Criterion(Reflections.fnToFieldName(fn), "is not null", "and"));
        return this;
    }

    /**
     * AND column = value
     * 当value=null则不参与查询
     *
     * @param fn
     * @param value
     * @return
     */
    public SqlCriteriaHelper andEqualTo(Fn fn, Object value) {
        return this.andEqualTo(fn, value, false);
    }

    /**
     * AND column = value
     *
     * @param fn
     * @param value
     * @param required false 当value=null 则不参与查询 ;
     *                 true 当value = null 则转 is null 查询: AND column is null
     * @return
     */
    public SqlCriteriaHelper andEqualTo(Fn fn, Object value, boolean required) {
        if (Optional.ofNullable(value).isPresent()) {
            this.criteria.getCriterions().add(new Sqls.Criterion(Reflections.fnToFieldName(fn), value, "=", "and"));
        } else {
            if (required) {
                // null属性查询 转 is null
                this.criteria.getCriterions().add(new Sqls.Criterion(Reflections.fnToFieldName(fn), "is null", "and"));
            }
        }
        return this;
    }

    /**
     * AND column != value
     * 默认 value=null 则不参与查询
     *
     * @param fn
     * @param value
     * @return
     */
    public SqlCriteriaHelper andNotEqualTo(Fn fn, Object value) {
        return this.andNotEqualTo(fn, value, false);
    }

    /**
     * AND column != value
     *
     * @param fn
     * @param value
     * @param required false 当value=null 则不参与查询 ;
     *                 true 当value = null 则转 is not null 查询 : AND column is not null
     * @return
     */
    public SqlCriteriaHelper andNotEqualTo(Fn fn, Object value, boolean required) {
        if (Optional.ofNullable(value).isPresent()) {
            this.criteria.getCriterions().add(new Sqls.Criterion(Reflections.fnToFieldName(fn), value, "<>", "and"));
        } else {
            if (required) {
                //转非空查询
                this.andIsNotNull(fn);
            }
        }
        return this;
    }

    /**
     * AND column > value
     * 当 value = null 则当前属性不参与查询
     *
     * @param fn
     * @param value
     * @return
     */
    public SqlCriteriaHelper andGreaterThan(Fn fn, Object value) {
        if (Optional.ofNullable(value).isPresent()) {
            this.criteria.getCriterions().add(new Sqls.Criterion(Reflections.fnToFieldName(fn), value, ">", "and"));
        }
        return this;
    }

    /**
     * AND  column >= value
     * 当 value = null 则当前属性不参与查询
     *
     * @param fn
     * @param value
     * @return
     */
    public SqlCriteriaHelper andGreaterThanOrEqualTo(Fn fn, Object value) {
        if (Optional.ofNullable(value).isPresent()) {
            this.criteria.getCriterions().add(new Sqls.Criterion(Reflections.fnToFieldName(fn), value, ">=", "and"));
        }
        return this;
    }

    /**
     * AND  column < value
     * 当 value = null 则当前属性不参与查询
     *
     * @param fn
     * @param value
     * @return
     */
    public SqlCriteriaHelper andLessThan(Fn fn, Object value) {
        if (Optional.ofNullable(value).isPresent()) {
            this.criteria.getCriterions().add(new Sqls.Criterion(Reflections.fnToFieldName(fn), value, "<", "and"));
        }
        return this;
    }

    /**
     * AND  column <= value
     * 当 value = null 则当前属性不参与查询
     *
     * @param fn
     * @param value
     * @return
     */
    public SqlCriteriaHelper andLessThanOrEqualTo(Fn fn, Object value) {
        if (Optional.ofNullable(value).isPresent()) {
            this.criteria.getCriterions().add(new Sqls.Criterion(Reflections.fnToFieldName(fn), value, "<=", "and"));
        }
        return this;
    }

    /**
     * AND  column IN (#{item.value})
     * 当 values = null 则当前属性不参与查询
     *
     * @param fn
     * @param values
     * @return
     */
    public SqlCriteriaHelper andIn(Fn fn, Iterable values) {
        if (Optional.ofNullable(values).isPresent() && values.iterator().hasNext()) {
            this.criteria.getCriterions().add(new Sqls.Criterion(Reflections.fnToFieldName(fn), values, "in", "and"));
        }
        return this;
    }

    /**
     * AND  column NOT IN (#{item.value})
     * 当 values = null 则当前属性不参与查询
     *
     * @param fn
     * @param values
     * @return
     */
    public SqlCriteriaHelper andNotIn(Fn fn, Iterable values) {
        if (Optional.ofNullable(values).isPresent() && values.iterator().hasNext()) {
            this.criteria.getCriterions().add(new Sqls.Criterion(Reflections.fnToFieldName(fn), values, "not in", "and"));
        }
        return this;
    }

    /**
     * AND  column BETWEEN  value1 AND value2
     * 当 value1 或 value2 为空 则当前属性不参与查询
     *
     * @param fn
     * @param value1
     * @param value2
     * @return
     */
    public SqlCriteriaHelper andBetween(Fn fn, Object value1, Object value2) {
        if (Optional.ofNullable(value1).isPresent() && Optional.ofNullable(value2).isPresent()) {
            this.criteria.getCriterions().add(new Sqls.Criterion(Reflections.fnToFieldName(fn), value1, value2, "between", "and"));
        }
        return this;
    }

    /**
     * AND column  NOT BETWEEN value1 AND value2
     * 当 value1 或 value2 为空 则当前属性不参与查询
     *
     * @param fn
     * @param value1
     * @param value2
     * @return
     */
    public SqlCriteriaHelper andNotBetween(Fn fn, Object value1, Object value2) {
        if (Optional.ofNullable(value1).isPresent() && Optional.ofNullable(value2).isPresent()) {
            this.criteria.getCriterions().add(new Sqls.Criterion(Reflections.fnToFieldName(fn), value1, value2, "not between", "and"));
        }
        return this;
    }

    /**
     * AND column LIKE %value%
     * 当 value = null 则当前属性不参与查询
     *
     * @param fn
     * @param value
     * @return
     */
    public SqlCriteriaHelper andLike(Fn fn, String value) {
        if (Optional.ofNullable(value).isPresent()) {
            value = "%" + value + "%";
            this.criteria.getCriterions().add(new Sqls.Criterion(Reflections.fnToFieldName(fn), value, "like", "and"));
        }
        return this;
    }


    /**
     * AND column LIKE %value
     * 当 value = null 则当前属性不参与查询
     *
     * @param fn
     * @param value
     * @return
     */
    public SqlCriteriaHelper andLikeLeft(Fn fn, String value) {
        if (Optional.ofNullable(value).isPresent()) {
            value = "%" + value;
            this.criteria.getCriterions().add(new Sqls.Criterion(Reflections.fnToFieldName(fn), value, "like", "and"));
        }
        return this;
    }

    /**
     * AND column LIKE value%
     * 当 value = null 则当前属性不参与查询
     *
     * @param fn
     * @param value
     * @return
     */
    public SqlCriteriaHelper andLikeRight(Fn fn, String value) {
        if (Optional.ofNullable(value).isPresent()) {
            value = value + "%";
            this.criteria.getCriterions().add(new Sqls.Criterion(Reflections.fnToFieldName(fn), value, "like", "and"));
        }
        return this;
    }

    /**
     * AND column NOT LIKE %value%
     * 当 value = null 则当前属性不参与查询
     *
     * @param fn
     * @param value
     * @return
     */
    public SqlCriteriaHelper andNotLike(Fn fn, String value) {
        if (Optional.ofNullable(value).isPresent()) {
            value = "%" + value + "%";
            this.criteria.getCriterions().add(new Sqls.Criterion(Reflections.fnToFieldName(fn), value, "not like", "and"));
        }
        return this;
    }

    /**
     * AND column NOT LIKE %value
     * 当 value = null 则当前属性不参与查询
     *
     * @param fn
     * @param value
     * @return
     */
    public SqlCriteriaHelper andNotLikeLeft(Fn fn, String value) {
        if (Optional.ofNullable(value).isPresent()) {
            value = "%" + value + "%";
            this.criteria.getCriterions().add(new Sqls.Criterion(Reflections.fnToFieldName(fn), value, "not like", "and"));
        }
        return this;
    }

    /**
     * AND column NOT LIKE value%
     * 当 value = null 则当前属性不参与查询
     *
     * @param fn
     * @param value
     * @return
     */
    public SqlCriteriaHelper andNotLikeRight(Fn fn, String value) {
        if (Optional.ofNullable(value).isPresent()) {
            value = value + "%";
            this.criteria.getCriterions().add(new Sqls.Criterion(Reflections.fnToFieldName(fn), value, "not like", "and"));
        }
        return this;
    }

    /**
     * OR column IS NULL
     * 当 value = null 则当前属性不参与查询
     *
     * @param fn
     * @return
     */
    public SqlCriteriaHelper orIsNull(Fn fn) {
        this.criteria.getCriterions().add(new Sqls.Criterion(Reflections.fnToFieldName(fn), "is null", "or"));
        return this;
    }

    /**
     * OR column IS NOT NULL
     * 当 value = null 则当前属性不参与查询
     *
     * @param fn
     * @return
     */
    public SqlCriteriaHelper orIsNotNull(Fn fn) {
        this.criteria.getCriterions().add(new Sqls.Criterion(Reflections.fnToFieldName(fn), "is not null", "or"));
        return this;
    }


    /**
     * OR column = value
     * 当 value = null 则当前属性不参与查询
     *
     * @param fn
     * @param value
     * @return
     */
    public SqlCriteriaHelper orEqualTo(Fn fn, Object value) {
        return this.orEqualTo(fn, value, false);
    }

    /**
     * OR column = value
     * 当request = true 且  value = null时 转 #{@link #orIsNull(Fn)}
     *
     * @param fn
     * @param value
     * @param required
     * @return
     */
    public SqlCriteriaHelper orEqualTo(Fn fn, Object value, boolean required) {
        if (Optional.ofNullable(value).isPresent()) {
            this.criteria.getCriterions().add(new Sqls.Criterion(Reflections.fnToFieldName(fn), value, "=", "or"));
        } else {
            if (required) {
                //转 or null
                this.criteria.getCriterions().add(new Sqls.Criterion(Reflections.fnToFieldName(fn), "is null", "or"));
            }
        }
        return this;
    }

    /**
     * OR column <> value
     * 当value = null 则当前属性不参与查询
     *
     * @param fn
     * @param value
     * @return
     */
    public SqlCriteriaHelper orNotEqualTo(Fn fn, Object value) {
        return this.orNotEqualTo(fn, value, false);
    }

    /**
     * OR column <> value
     * 当request = true 且  value = null时 转 #{@link #orIsNotNull(Fn)}
     *
     * @param fn
     * @param value
     * @param required
     * @return
     */
    public SqlCriteriaHelper orNotEqualTo(Fn fn, Object value, boolean required) {
        if (Optional.ofNullable(value).isPresent()) {
            this.criteria.getCriterions().add(new Sqls.Criterion(Reflections.fnToFieldName(fn), value, "<>", "or"));
        } else {
            if (required) {
                // 转 or is not null
                this.orIsNotNull(fn);
            }
        }
        return this;
    }

    /**
     * OR column > value
     * 当value = null 则当前属性不参与查询
     *
     * @param fn
     * @param value
     * @return
     */
    public SqlCriteriaHelper orGreaterThan(Fn fn, String value) {
        if (Optional.ofNullable(value).isPresent()) {
            this.criteria.getCriterions().add(new Sqls.Criterion(Reflections.fnToFieldName(fn), value, ">", "or"));
        }
        return this;
    }

    /**
     * OR column >= value
     * 当value = null 则当前属性不参与查询
     *
     * @param fn
     * @param value
     * @return
     */
    public SqlCriteriaHelper orGreaterThanOrEqualTo(Fn fn, String value) {
        if (Optional.ofNullable(value).isPresent()) {
            this.criteria.getCriterions().add(new Sqls.Criterion(Reflections.fnToFieldName(fn), value, ">=", "or"));
        }
        return this;
    }

    /**
     * OR column < value
     * 当value = null 则当前属性不参与查询
     *
     * @param fn
     * @param value
     * @return
     */
    public SqlCriteriaHelper orLessThan(Fn fn, String value) {
        if (Optional.ofNullable(value).isPresent()) {
            this.criteria.getCriterions().add(new Sqls.Criterion(Reflections.fnToFieldName(fn), value, "<", "or"));
        }
        return this;
    }

    /**
     * OR column <= value
     * 当value = null 则当前属性不参与查询
     *
     * @param fn
     * @param value
     * @return
     */
    public SqlCriteriaHelper orLessThanOrEqualTo(Fn fn, String value) {
        if (Optional.ofNullable(value).isPresent()) {
            this.criteria.getCriterions().add(new Sqls.Criterion(Reflections.fnToFieldName(fn), value, "<=", "or"));
        }
        return this;
    }

    /**
     * OR column IN (#{item.value})
     * 当value = null 则当前属性不参与查询
     *
     * @param fn
     * @param values
     * @return
     */
    public SqlCriteriaHelper orIn(Fn fn, Iterable values) {
        if (Optional.ofNullable(values).isPresent() && values.iterator().hasNext()) {
            this.criteria.getCriterions().add(new Sqls.Criterion(Reflections.fnToFieldName(fn), values, "in", "or"));
        }
        return this;
    }

    /**
     * OR column NOT IN (#{item.value})
     * 当value = null 则当前属性不参与查询
     *
     * @param fn
     * @param values
     * @return
     */
    public SqlCriteriaHelper orNotIn(Fn fn, Iterable values) {
        if (Optional.ofNullable(values).isPresent() && values.iterator().hasNext()) {
            this.criteria.getCriterions().add(new Sqls.Criterion(Reflections.fnToFieldName(fn), values, "not in", "or"));
        }
        return this;
    }

    /**
     * OR column BETWEEN  value1 AND value2
     * 当 value1 或 value2 为空 则当前属性不参与查询
     *
     * @param fn
     * @param value1
     * @param value2
     * @return
     */
    public SqlCriteriaHelper orBetween(Fn fn, Object value1, Object value2) {
        if (Optional.ofNullable(value1).isPresent() && Optional.ofNullable(value2).isPresent()) {
            this.criteria.getCriterions().add(new Sqls.Criterion(Reflections.fnToFieldName(fn), value1, value2, "between", "or"));
        }
        return this;
    }

    /**
     * OR column NOT BETWEEN  value1 AND value2
     * 当 value1 或 value2 为空 则当前属性不参与查询
     *
     * @param fn
     * @param value1
     * @param value2
     * @return
     */
    public SqlCriteriaHelper orNotBetween(Fn fn, Object value1, Object value2) {
        if (Optional.ofNullable(value1).isPresent() && Optional.ofNullable(value2).isPresent()) {
            this.criteria.getCriterions().add(new Sqls.Criterion(Reflections.fnToFieldName(fn), value1, value2, "not between", "or"));
        }
        return this;
    }


    /**
     * OR column LIKE value
     * 当 value = null 则当前属性不参与查询
     *
     * @param fn
     * @param value
     * @return
     */
    public SqlCriteriaHelper orLike(Fn fn, String value) {
        if (Optional.ofNullable(value).isPresent()) {
            value = "%" + value + "%";
            this.criteria.getCriterions().add(new Sqls.Criterion(Reflections.fnToFieldName(fn), value, "like", "or"));
        }
        return this;
    }


    /**
     * OR column LIKE %value
     * 当 value = null 则当前属性不参与查询
     *
     * @param fn
     * @param value
     * @return
     */
    public SqlCriteriaHelper orLikeLeft(Fn fn, String value) {
        if (Optional.ofNullable(value).isPresent()) {
            value = "%" + value;
            this.criteria.getCriterions().add(new Sqls.Criterion(Reflections.fnToFieldName(fn), value, "like", "or"));
        }
        return this;
    }


    /**
     * OR column LIKE value%
     * 当 value = null 则当前属性不参与查询
     *
     * @param fn
     * @param value
     * @return
     */
    public SqlCriteriaHelper orLikeRight(Fn fn, String value) {
        if (Optional.ofNullable(value).isPresent()) {
            value = value + "%";
            this.criteria.getCriterions().add(new Sqls.Criterion(Reflections.fnToFieldName(fn), value, "like", "or"));
        }
        return this;
    }


    /**
     * OR column NOT LIKE value
     * 当 value = null 则当前属性不参与查询
     *
     * @param fn
     * @param value
     * @return
     */
    public SqlCriteriaHelper orNotLike(Fn fn, String value) {
        if (Optional.ofNullable(value).isPresent()) {
            value = "%" + value + "%";
            this.criteria.getCriterions().add(new Sqls.Criterion(Reflections.fnToFieldName(fn), value, "not like", "or"));
        }
        return this;
    }


    /**
     * OR column NOT LIKE %value
     * 当 value = null 则当前属性不参与查询
     *
     * @param fn
     * @param value
     * @return
     */
    public SqlCriteriaHelper orNotLikeLeft(Fn fn, String value) {
        if (Optional.ofNullable(value).isPresent()) {
            value = "%" + value;
            this.criteria.getCriterions().add(new Sqls.Criterion(Reflections.fnToFieldName(fn), value, "not like", "or"));
        }
        return this;
    }

    /**
     * OR column NOT LIKE value%
     * 当 value = null 则当前属性不参与查询
     *
     * @param fn
     * @param value
     * @return
     */
    public SqlCriteriaHelper orNotLikeRight(Fn fn, String value) {
        if (Optional.ofNullable(value).isPresent()) {
            value = value + "%";
            this.criteria.getCriterions().add(new Sqls.Criterion(Reflections.fnToFieldName(fn), value, "not like", "or"));
        }
        return this;
    }


    @Override
    public Sqls.Criteria getCriteria() {
        return criteria;
    }
}




© 2015 - 2025 Weber Informatics LLC | Privacy Policy