package com.xmomen.module.base.entity;

import com.xmomen.framework.mybatis.model.BaseMybatisExample;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

// 定义一个CdCouponExample类，继承自BaseMybatisExample类
public class CdCouponExample extends BaseMybatisExample {
    // 定义一个orderByClause变量，用于存储排序字段
    protected String orderByClause;

    // 定义一个distinct变量，用于存储是否去重
    protected boolean distinct;

    // 定义一个oredCriteria变量，用于存储查询条件
    protected List<Criteria> oredCriteria;

    // 构造函数，初始化oredCriteria变量
    public CdCouponExample() {
        oredCriteria = new ArrayList<Criteria>();
    }

    // 设置排序字段
    public void setOrderByClause(String orderByClause) {
        this.orderByClause = orderByClause;
    }

    // 获取排序字段
    public String getOrderByClause() {
        return orderByClause;
    }

    // 设置是否去重
    public void setDistinct(boolean distinct) {
        this.distinct = distinct;
    }

    // 获取是否去重
    public boolean isDistinct() {
        return distinct;
    }

    // 获取查询条件
    public List<Criteria> getOredCriteria() {
        return oredCriteria;
    }

    // 添加查询条件
    public void or(Criteria criteria) {
        oredCriteria.add(criteria);
    }

    // 创建查询条件
    public Criteria or() {
        Criteria criteria = createCriteriaInternal();
        oredCriteria.add(criteria);
        return criteria;
    }

    // 创建查询条件
    public Criteria createCriteria() {
        Criteria criteria = createCriteriaInternal();
        if (oredCriteria.size() == 0) {
            oredCriteria.add(criteria);
        }
        return criteria;
    }

    // 创建查询条件
    protected Criteria createCriteriaInternal() {
        Criteria criteria = new Criteria();
        return criteria;
    }

    // 清空查询条件
    public void clear() {
        oredCriteria.clear();
        orderByClause = null;
        distinct = false;
    }

    // 定义一个GeneratedCriteria内部类，用于存储查询条件
    protected abstract static class GeneratedCriteria {
        // 定义一个criteria变量，用于存储查询条件
        protected List<Criterion> criteria;

        // 构造函数，初始化criteria变量
        protected GeneratedCriteria() {
            super();
            criteria = new ArrayList<Criterion>();
        }

        // 判断查询条件是否有效
        public boolean isValid() {
            return criteria.size() > 0;
        }

        // 获取所有查询条件
        public List<Criterion> getAllCriteria() {
            return criteria;
        }

        // 获取查询条件
        public List<Criterion> getCriteria() {
            return criteria;
        }

        // 添加查询条件
        protected void addCriterion(String condition) {
            if (condition == null) {
                throw new RuntimeException("Value for condition cannot be null");
            }
            criteria.add(new Criterion(condition));
        }

        // 添加查询条件
        protected void addCriterion(String condition, Object value, String property) {
            if (value == null) {
                throw new RuntimeException("Value for " + property + " cannot be null");
            }
            criteria.add(new Criterion(condition, value));
        }

        // 添加查询条件
        protected void addCriterion(String condition, Object value1, Object value2, String property) {
            if (value1 == null || value2 == null) {
                throw new RuntimeException("Between values for " + property + " cannot be null");
            }
            criteria.add(new Criterion(condition, value1, value2));
        }

        // 添加查询条件，判断ID是否为空
        public Criteria andIdIsNull() {
            addCriterion("ID is null");
            return (Criteria) this;
        }

        // 添加查询条件，判断ID是否不为空
        public Criteria andIdIsNotNull() {
            addCriterion("ID is not null");
            return (Criteria) this;
        }

        // 添加查询条件，判断ID是否等于某个值
        public Criteria andIdEqualTo(Integer value) {
            addCriterion("ID =", value, "id");
            return (Criteria) this;
        }

        // 添加查询条件，判断ID是否不等于某个值
        public Criteria andIdNotEqualTo(Integer value) {
            addCriterion("ID <>", value, "id");
            return (Criteria) this;
        }

        // 添加查询条件，判断ID是否大于某个值
        public Criteria andIdGreaterThan(Integer value) {
            addCriterion("ID >", value, "id");
            return (Criteria) this;
        }

        // 添加查询条件，判断ID是否大于等于某个值
        public Criteria andIdGreaterThanOrEqualTo(Integer value) {
            addCriterion("ID >=", value, "id");
            return (Criteria) this;
        }

        // 添加查询条件，判断ID是否小于某个值
        public Criteria andIdLessThan(Integer value) {
            addCriterion("ID <", value, "id");
            return (Criteria) this;
        }

        // 添加查询条件，判断ID是否小于等于某个值
        public Criteria andIdLessThanOrEqualTo(Integer value) {
            addCriterion("ID <=", value, "id");
            return (Criteria) this;
        }

        // 添加查询条件，判断ID是否在某个范围内
        public Criteria andIdIn(List<Integer> values) {
            addCriterion("ID in", values, "id");
            return (Criteria) this;
        }

        // 添加查询条件，判断ID是否不在某个范围内
        public Criteria andIdNotIn(List<Integer> values) {
            addCriterion("ID not in", values, "id");
            return (Criteria) this;
        }

        // 添加查询条件，判断ID是否在某个范围内
        public Criteria andIdBetween(Integer value1, Integer value2) {
            addCriterion("ID between", value1, value2, "id");
            return (Criteria) this;
        }

        // 添加查询条件，判断ID是否不在某个范围内
        public Criteria andIdNotBetween(Integer value1, Integer value2) {
            addCriterion("ID not between", value1, value2, "id");
            return (Criteria) this;
        }

        // 添加查询条件，判断COUPON_TYPE是否为空
        public Criteria andCouponTypeIsNull() {
            addCriterion("COUPON_TYPE is null");
            return (Criteria) this;
        }

        // 添加查询条件，判断COUPON_TYPE是否不为空
        public Criteria andCouponTypeIsNotNull() {
            addCriterion("COUPON_TYPE is not null");
            return (Criteria) this;
        }

        // 添加查询条件，判断COUPON_TYPE是否等于某个值
        public Criteria andCouponTypeEqualTo(Integer value) {
            addCriterion("COUPON_TYPE =", value, "couponType");
            return (Criteria) this;
        }

        // 添加查询条件，判断COUPON_TYPE是否不等于某个值
        public Criteria andCouponTypeNotEqualTo(Integer value) {
            addCriterion("COUPON_TYPE <>", value, "couponType");
            return (Criteria) this;
        }

        // 添加查询条件，判断COUPON_TYPE是否大于某个值
        public Criteria andCouponTypeGreaterThan(Integer value) {
            addCriterion("COUPON_TYPE >", value, "couponType");
            return (Criteria) this;
        }

        // 添加查询条件，判断COUPON_TYPE是否大于等于某个值
        public Criteria andCouponTypeGreaterThanOrEqualTo(Integer value) {
            addCriterion("COUPON_TYPE >=", value, "couponType");
            return (Criteria) this;
        }

        // 添加查询条件，判断COUPON_TYPE是否小于某个值
        public Criteria andCouponTypeLessThan(Integer value) {
            addCriterion("COUPON_TYPE <", value, "couponType");
            return (Criteria) this;
        }

        // 添加查询条件，判断COUPON_TYPE是否小于等于某个值
        public Criteria andCouponTypeLessThanOrEqualTo(Integer value) {
            addCriterion("COUPON_TYPE <=", value, "couponType");
            return (Criteria) this;
        }

        // 添加查询条件，判断COUPON_TYPE是否在某个范围内
        public Criteria andCouponTypeIn(List<Integer> values) {
            addCriterion("COUPON_TYPE in", values, "couponType");
            return (Criteria) this;
        }

        // 添加查询条件，判断COUPON_TYPE是否不在某个范围内
        public Criteria andCouponTypeNotIn(List<Integer> values) {
            addCriterion("COUPON_TYPE not in", values, "couponType");
            return (Criteria) this;
        }

        // 添加查询条件，判断COUPON_TYPE是否在某个范围内
        public Criteria andCouponTypeBetween(Integer value1, Integer value2) {
            addCriterion("COUPON_TYPE between", value1, value2, "couponType");
            return (Criteria) this;
        }

        // 添加查询条件，判断COUPON_TYPE是否不在某个范围内
        public Criteria andCouponTypeNotBetween(Integer value1, Integer value2) {
            addCriterion("COUPON_TYPE not between", value1, value2, "couponType");
            return (Criteria) this;
        }

        // 添加查询条件，判断COUPON_CATEGORY是否为空
        public Criteria andCouponCategoryIsNull() {
            addCriterion("COUPON_CATEGORY is null");
            return (Criteria) this;
        }

        // 添加查询条件，判断COUPON_CATEGORY是否不为空
        public Criteria andCouponCategoryIsNotNull() {
            addCriterion("COUPON_CATEGORY is not null");
            return (Criteria) this;
        }

        // 添加查询条件，判断COUPON_CATEGORY是否等于某个值
        public Criteria andCouponCategoryEqualTo(Integer value) {
            addCriterion("COUPON_CATEGORY =", value, "couponCategory");
            return (Criteria) this;
        }

        // 添加查询条件，判断COUPON_CATEGORY是否不等于某个值
        public Criteria andCouponCategoryNotEqualTo(Integer value) {
            addCriterion("COUPON_CATEGORY <>", value, "couponCategory");
            return (Criteria) this;
        }

        // 添加查询条件，判断COUPON_CATEGORY是否大于某个值
        public Criteria andCouponCategoryGreaterThan(Integer value) {
            addCriterion("COUPON_CATEGORY >", value, "couponCategory");
            return (Criteria) this;
        }

        // 添加查询条件，判断COUPON_CATEGORY是否大于等于某个值
        public Criteria andCouponCategoryGreaterThanOrEqualTo(Integer value) {
            addCriterion("COUPON_CATEGORY >=", value, "couponCategory");
            return (Criteria) this;
        }

        // 添加查询条件，判断COUPON_CATEGORY是否小于某个值
        public Criteria andCouponCategoryLessThan(Integer value) {
            addCriterion("COUPON_CATEGORY <", value, "couponCategory");
            return (Criteria) this;
        }

        // 添加查询条件，判断COUPON_CATEGORY是否小于等于某个值
        public Criteria andCouponCategoryLessThanOrEqualTo(Integer value) {
            addCriterion("COUPON_CATEGORY <=", value, "couponCategory");
            return (Criteria) this;
        }

        // 添加查询条件，判断COUPON_CATEGORY是否在某个范围内
        public Criteria andCouponCategoryIn(List<Integer> values) {
            addCriterion("COUPON_CATEGORY in", values, "couponCategory");
            return (Criteria) this;
        }

        // 添加查询条件，判断COUPON_CATEGORY是否不在某个范围内
        public Criteria andCouponCategoryNotIn(List<Integer> values) {
            addCriterion("COUPON_CATEGORY not in", values, "couponCategory");
            return (Criteria) this;
        }

        // 添加查询条件，判断COUPON_CATEGORY是否在某个范围内
        public Criteria andCouponCategoryBetween(Integer value1, Integer value2) {
            addCriterion("COUPON_CATEGORY between", value1, value2, "couponCategory");
            return (Criteria) this;
        }

        // 添加查询条件，判断COUPON_CATEGORY是否不在某个范围内
        public Criteria andCouponCategoryNotBetween(Integer value1, Integer value2) {
            addCriterion("COUPON_CATEGORY not between", value1, value2, "couponCategory");
            return (Criteria) this;
        }

        // 添加查询条件，判断COUPON_NUMBER是否为空
        public Criteria andCouponNumberIsNull() {
            addCriterion("COUPON_NUMBER is null");
            return (Criteria) this;
        }

        // 添加查询条件，判断COUPON_NUMBER是否不为空
        public Criteria andCouponNumberIsNotNull() {
            addCriterion("COUPON_NUMBER is not null");
            return (Criteria) this;
        }

        // 添加查询条件，判断COUPON_NUMBER是否等于某个值
        public Criteria andCouponNumberEqualTo(String value) {
            addCriterion("COUPON_NUMBER =", value, "couponNumber");
            return (Criteria) this;
        }

        // 添加查询条件，判断COUPON_NUMBER是否不等于某个值
        public Criteria andCouponNumberNotEqualTo(String value) {
            addCriterion("COUPON_NUMBER <>", value, "couponNumber");
            return (Criteria) this;
        }

        // 添加查询条件，判断COUPON_NUMBER是否大于某个值
        public Criteria andCouponNumberGreaterThan(String value) {
            addCriterion("COUPON_NUMBER >", value, "couponNumber");
            return (Criteria) this;
        }

        // 添加查询条件，判断COUPON_NUMBER是否大于等于某个值
        public Criteria andCouponNumberGreaterThanOrEqualTo(String value) {
            addCriterion("COUPON_NUMBER >=", value, "couponNumber");
            return (Criteria) this;
        }

        // 添加查询条件，判断COUPON_NUMBER是否小于某个值
        public Criteria andCouponNumberLessThan(String value) {
            addCriterion("COUPON_NUMBER <", value, "couponNumber");
            return (Criteria) this;
        }

        // 添加查询条件，判断COUPON_NUMBER是否小于等于某个值
        public Criteria andCouponNumberLessThanOrEqualTo(String value) {
            addCriterion("COUPON_NUMBER <=", value, "couponNumber");
            return (Criteria) this;
        }

        // 添加查询条件，判断COUPON_NUMBER是否包含某个值
        public Criteria andCouponNumberLike(String value) {
            addCriterion("COUPON_NUMBER like", value, "couponNumber");
            return (Criteria) this;
        }

        // 添加查询条件，判断COUPON_NUMBER是否不包含某个值
        public Criteria andCouponNumberNotLike(String value) {
            addCriterion("COUPON_NUMBER not like", value, "couponNumber");
            return (Criteria) this;
        }

        // 添加查询条件，判断COUPON_NUMBER是否在某个范围内
        public Criteria andCouponNumberIn(List<String> values) {
            addCriterion("COUPON_NUMBER in", values, "couponNumber");
            return (Criteria) this;
        }

        // 添加查询条件，判断COUPON_NUMBER是否不在某个范围内
        public Criteria andCouponNumberNotIn(List<String> values) {
            addCriterion("COUPON_NUMBER not in", values, "couponNumber");
            return (Criteria) this;
        }

        // 添加查询条件，判断COUPON_NUMBER是否在某个范围内
        public Criteria andCouponNumberBetween(String value1, String value2) {
            addCriterion("COUPON_NUMBER between", value1, value2, "couponNumber");
            return (Criteria) this;
        }

        // 添加查询条件，判断COUPON_NUMBER是否不在某个范围内
        public Criteria andCouponNumberNotBetween(String value1, String value2) {
            addCriterion("COUPON_NUMBER not between", value1, value2, "couponNumber");
            return (Criteria) this;
        }

        // 添加查询条件，判断COUPON_PASSWORD是否为空
        public Criteria andCouponPasswordIsNull() {
            addCriterion("COUPON_PASSWORD is null");
            return (Criteria) this;
        }

        // 添加查询条件，判断COUPON_PASSWORD是否不为空
        public Criteria andCouponPasswordIsNotNull() {
            addCriterion("COUPON_PASSWORD is not null");
            return (Criteria) this;
        }

        // 添加查询条件，判断COUPON_PASSWORD是否等于某个值
        public Criteria andCouponPasswordEqualTo(String value) {
            addCriterion("COUPON_PASSWORD =", value, "couponPassword");
            return (Criteria) this;
        }

        // 添加查询条件，判断COUPON_PASSWORD是否不等于某个值
        public Criteria andCouponPasswordNotEqualTo(String value) {
            addCriterion("COUPON_PASSWORD <>", value, "couponPassword");
            return (Criteria) this;
        }

        // 添加查询条件，判断COUPON_PASSWORD是否大于某个值
        public Criteria andCouponPasswordGreaterThan(String value) {
            addCriterion("COUPON_PASSWORD >", value, "couponPassword");
            return (Criteria) this;
        }

        // 添加查询条件，判断COUPON_PASSWORD是否大于等于某个值
        public Criteria andCouponPasswordGreaterThanOrEqualTo(String value) {
            addCriterion("COUPON_PASSWORD >=", value, "couponPassword");
            return (Criteria) this;
        }

        // 添加查询条件，判断COUPON_PASSWORD是否小于某个值
        public Criteria andCouponPasswordLessThan(String value) {
            addCriterion("COUPON_PASSWORD <", value, "couponPassword");
            return (Criteria) this;
        }

        // 添加查询条件，判断COUPON_PASSWORD是否小于等于某个值
        public Criteria andCouponPasswordLessThanOrEqualTo(String value) {
            addCriterion("COUPON_PASSWORD <=", value, "couponPassword");
            return (Criteria) this;
        }

        // 添加查询条件，判断COUPON_PASSWORD是否包含某个值
        public Criteria andCouponPasswordLike(String value) {
            addCriterion("COUPON_PASSWORD like", value, "couponPassword");
            return (Criteria) this;
        }

        // 添加查询条件，判断COUPON_PASSWORD是否不包含某个值
        public Criteria andCouponPasswordNotLike(String value) {
            addCriterion("COUPON_PASSWORD not like", value, "couponPassword");
            return (Criteria) this;
        }

        // 添加查询条件，判断COUPON_PASSWORD是否在某个范围内
        public Criteria andCouponPasswordIn(List<String> values) {
            addCriterion("COUPON_PASSWORD in", values, "couponPassword");
            return (Criteria) this;
        }

        // 添加查询条件，判断COUPON_PASSWORD是否不在某个范围内
        public Criteria andCouponPasswordNotIn(List<String> values) {
            addCriterion("COUPON_PASSWORD not in", values, "couponPassword");
            return (Criteria) this;
        }

        // 添加查询条件，判断COUPON_PASSWORD是否在某个范围内
        public Criteria andCouponPasswordBetween(String value1, String value2) {
            addCriterion("COUPON_PASSWORD between", value1, value2, "couponPassword");
            return (Criteria) this;
        }

        // 添加查询条件，判断COUPON_PASSWORD是否不在某个范围内
        public Criteria andCouponPasswordNotBetween(String value1, String value2) {
            addCriterion("COUPON_PASSWORD not between", value1, value2, "couponPassword");
            return (Criteria) this;
        }

        // 添加查询条件，判断COUPON_VALUE是否为空
        public Criteria andCouponValueIsNull() {
            addCriterion("COUPON_VALUE is null");
            return (Criteria) this;
        }

        // 添加查询条件，判断COUPON_VALUE是否不为空
        public Criteria andCouponValueIsNotNull() {
            addCriterion("COUPON_VALUE is not null");
            return (Criteria) this;
        }

        // 添加查询条件，判断COUPON_VALUE是否等于某个值
        public Criteria andCouponValueEqualTo(BigDecimal value) {
            addCriterion("COUPON_VALUE =", value, "couponValue");
            return (Criteria) this;
        }

        // 添加查询条件，判断COUPON_VALUE是否不等于某个值
        public Criteria andCouponValueNotEqualTo(BigDecimal value) {
            addCriterion("COUPON_VALUE <>", value, "couponValue");
            return (Criteria) this;
        }

        // 添加查询条件，判断COUPON_VALUE是否大于某个值
        public Criteria andCouponValueGreaterThan(BigDecimal value) {
            addCriterion("COUPON_VALUE >", value, "couponValue");
            return (Criteria) this;
        }

        // 添加查询条件，判断COUPON_VALUE是否大于等于某个值
        public Criteria andCouponValueGreaterThanOrEqualTo(BigDecimal value) {
            addCriterion("COUPON_VALUE >=", value, "couponValue");
            return (Criteria) this;
        }

        // 添加查询条件，判断COUPON_VALUE是否小于某个值
        public Criteria andCouponValueLessThan(BigDecimal value) {
            addCriterion("COUPON_VALUE <", value, "couponValue");
            return (Criteria) this;
        }

        // 添加查询条件，判断COUPON_VALUE是否小于等于某个值
        public Criteria andCouponValueLessThanOrEqualTo(BigDecimal value) {
            addCriterion("COUPON_VALUE <=", value, "couponValue");
            return (Criteria) this;
        }

        // 添加查询条件，判断COUPON_VALUE是否包含某个值
        public Criteria andCouponValueIn(List<BigDecimal> values) {
            addCriterion("COUPON_VALUE in", values, "couponValue");
            return (Criteria) this;
        }

        // 添加查询条件，判断COUPON_VALUE是否不包含某个值
        public Criteria andCouponValueNotIn(List<BigDecimal> values) {
            addCriterion("COUPON_VALUE not in", values, "couponValue");
            return (Criteria) this;
        }

        // 添加查询条件，判断COUPON_VALUE是否在某个范围内
        public Criteria andCouponValueBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("COUPON_VALUE between", value1, value2, "couponValue");
            return (Criteria) this;
        }

        // 添加查询条件，判断COUPON_VALUE是否不在某个范围内
        public Criteria andCouponValueNotBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("COUPON_VALUE not between", value1, value2, "couponValue");
            return (Criteria) this;
        }

        // 添加查询条件，判断USER_PRICE是否为空
        public Criteria andUserPriceIsNull() {
            addCriterion("USER_PRICE is null");
            return (Criteria) this;
        }

        // 添加查询条件，判断USER_PRICE是否不为空
        public Criteria andUserPriceIsNotNull() {
            addCriterion("USER_PRICE is not null");
            return (Criteria) this;
        }

        // 添加查询条件，判断USER_PRICE是否等于某个值
        public Criteria andUserPriceEqualTo(BigDecimal value) {
            addCriterion("USER_PRICE =", value, "userPrice");
            return (Criteria) this;
        }

        // 添加查询条件，判断USER_PRICE是否不等于某个值
        public Criteria andUserPriceNotEqualTo(BigDecimal value) {
            addCriterion("USER_PRICE <>", value, "userPrice");
            return (Criteria) this;
        }

        // 添加查询条件，判断USER_PRICE是否大于某个值
        public Criteria andUserPriceGreaterThan(BigDecimal value) {
            addCriterion("USER_PRICE >", value, "userPrice");
            return (Criteria) this;
        }

        // 添加查询条件，判断USER_PRICE是否大于等于某个值
        public Criteria andUserPriceGreaterThanOrEqualTo(BigDecimal value) {
            addCriterion("USER_PRICE >=", value, "userPrice");
            return (Criteria) this;
        }

        // 添加查询条件，判断USER_PRICE是否小于某个值
        public Criteria andUserPriceLessThan(BigDecimal value) {
            addCriterion("USER_PRICE <", value, "userPrice");
            return (Criteria) this;
        }

        // 添加查询条件，判断USER_PRICE是否小于等于某个值
        public Criteria andUserPriceLessThanOrEqualTo(BigDecimal value) {
            addCriterion("USER_PRICE <=", value, "userPrice");
            return (Criteria) this;
        }

        // 添加查询条件，判断USER_PRICE是否包含某个值
        public Criteria andUserPriceIn(List<BigDecimal> values) {
            addCriterion("USER_PRICE in", values, "userPrice");
            return (Criteria) this;
        }

        // 添加查询条件，判断USER_PRICE是否不包含某个值
        public Criteria andUserPriceNotIn(List<BigDecimal> values) {
            addCriterion("USER_PRICE not in", values, "userPrice");
            return (Criteria) this;
        }

        // 添加查询条件，判断USER_PRICE是否在某个范围内
        public Criteria andUserPriceBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("USER_PRICE between", value1, value2, "userPrice");
            return (Criteria) this;
        }

        // 添加查询条件，判断USER_PRICE是否不在某个范围内
        public Criteria andUserPriceNotBetween(BigDecimal value1, BigDecimal value2) {
            addCriterion("USER_PRICE not between", value1, value2, "userPrice");
            return (Criteria) this;
        }

        // 添加查询条件，判断CD_COMPANY_ID是否为空
        public Criteria andCdCompanyIdIsNull() {
            addCriterion("CD_COMPANY_ID is null");
            return (Criteria) this;
        }

        // 添加查询条件，判断CD_COMPANY_ID是否不为空
        public Criteria andCdCompanyIdIsNotNull() {
            addCriterion("CD_COMPANY_ID is not null");
            return (Criteria) this;
        }

        // 添加查询条件，判断CD_COMPANY_ID是否等于某个值
        public Criteria andCdCompanyIdEqualTo(Integer value) {
            addCriterion("CD_COMPANY_ID =", value, "cdCompanyId");
            return (Criteria) this;
        }

        // 添加查询条件，判断CD_COMPANY_ID是否不等于某个值
        public Criteria andCdCompanyIdNotEqualTo(Integer value) {
            addCriterion("CD_COMPANY_ID <>", value, "cdCompanyId");
            return (Criteria) this;
        }

        // 添加查询条件，判断CD_COMPANY_ID是否大于某个值
        public Criteria andCdCompanyIdGreaterThan(Integer value) {
            addCriterion("CD_COMPANY_ID >", value, "cdCompanyId");
            return (Criteria) this;
        }

        // 添加查询条件，判断CD_COMPANY_ID是否大于等于某个值
        public Criteria andCdCompanyIdGreaterThanOrEqualTo(Integer value) {
            addCriterion("CD_COMPANY_ID >=", value, "cdCompanyId");
            return (Criteria) this;
        }

        // 添加查询条件，判断CD_COMPANY_ID是否小于某个值
        public Criteria andCdCompanyIdLessThan(Integer value) {
            addCriterion("CD_COMPANY_ID <", value, "cdCompanyId");
            return (Criteria) this;
        }

        // 添加查询条件，判断CD_COMPANY_ID是否小于等于某个值
        public Criteria andCdCompanyIdLessThanOrEqualTo(Integer value) {
            addCriterion("CD_COMPANY_ID <=", value, "cdCompanyId");
            return (Criteria) this;
        }

        // 添加查询条件，判断CD_COMPANY_ID是否包含某个值
        public Criteria andCdCompanyIdIn(List<Integer> values) {
            addCriterion("CD_COMPANY_ID in", values, "cdCompanyId");
            return (Criteria) this;
        }

        // 添加查询条件，判断CD_COMPANY_ID是否不包含某个值
        public Criteria andCdCompanyIdNotIn(List<Integer> values) {
            addCriterion("CD_COMPANY_ID not in", values, "cdCompanyId");
            return (Criteria) this;
        }

        // 添加查询条件，判断CD_COMPANY_ID是否在某个范围内
        public Criteria andCdCompanyIdBetween(Integer value1, Integer value2) {
            addCriterion("CD_COMPANY_ID between", value1, value2, "cdCompanyId");
            return (Criteria) this;
        }

        // 添加查询条件，判断CD_COMPANY_ID是否不在某个范围内
        public Criteria andCdCompanyIdNotBetween(Integer value1, Integer value2) {
            addCriterion("CD_COMPANY_ID not between", value1, value2, "cdCompanyId");
            return (Criteria) this;
        }

        // 添加查询条件，判断CD_USER_ID是否为空
        public Criteria andCdUserIdIsNull() {
            addCriterion("CD_USER_ID is null");
            return (Criteria) this;
        }

        // 添加查询条件，判断CD_USER_ID是否不为空
        public Criteria andCdUserIdIsNotNull() {
            addCriterion("CD_USER_ID is not null");
            return (Criteria) this;
        }

        // 添加查询条件，判断CD_USER_ID是否等于某个值
        public Criteria andCdUserIdEqualTo(Integer value) {
            addCriterion("CD_USER_ID =", value, "cdUserId");
            return (Criteria) this;
        }

        // 添加查询条件，判断CD_USER_ID是否不等于某个值
        public Criteria andCdUserIdNotEqualTo(Integer value) {
            addCriterion("CD_USER_ID <>", value, "cdUserId");
            return (Criteria) this;
        }

        // 添加查询条件，判断CD_USER_ID是否大于某个值
        public Criteria andCdUserIdGreaterThan(Integer value) {
            addCriterion("CD_USER_ID >", value, "cdUserId");
            return (Criteria) this;
        }

        // 添加查询条件，判断CD_USER_ID是否大于等于某个值
        public Criteria andCdUserIdGreaterThanOrEqualTo(Integer value) {
            addCriterion("CD_USER_ID >=", value, "cdUserId");
            return (Criteria) this;
        }

        // 添加查询条件，判断CD_USER_ID是否小于某个值
        public Criteria andCdUserIdLessThan(Integer value) {
            addCriterion("CD_USER_ID <", value, "cdUserId");
            return (Criteria) this;
        }

        // 添加查询条件，判断CD_USER_ID是否小于等于某个值
        public Criteria andCdUserIdLessThanOrEqualTo(Integer value) {
            addCriterion("CD_USER_ID <=", value, "cdUserId");
            return (Criteria) this;
        }

        // 添加查询条件，判断CD_USER_ID是否包含某个值
        public Criteria andCdUserIdIn(List<Integer> values) {
            addCriterion("CD_USER_ID in", values, "cdUserId");
            return (Criteria) this;
        }

        // 添加查询条件，判断CD_USER_ID是否不包含某个值
        public Criteria andCdUserIdNotIn(List<Integer> values) {
            addCriterion("CD_USER_ID not in", values, "cdUserId");
            return (Criteria) this;
        }

        // 添加查询条件，判断CD_USER_ID是否在某个范围内
        public Criteria andCdUserIdBetween(Integer value1, Integer value2) {
            addCriterion("CD_USER_ID between", value1, value2, "cdUserId");
            return (Criteria) this;
        }

        // 添加查询条件，判断CD_USER_ID是否不在某个范围内
        public Criteria andCdUserIdNotBetween(Integer value1, Integer value2) {
            addCriterion("CD_USER_ID not between", value1, value2, "cdUserId");
            return (Criteria) this;
        }

        // 添加查询条件，判断COUPON_DESC是否为空
        public Criteria andCouponDescIsNull() {
            addCriterion("COUPON_DESC is null");
            return (Criteria) this;
        }

        // 添加查询条件，判断COUPON_DESC是否不为空
        public Criteria andCouponDescIsNotNull() {
            addCriterion("COUPON_DESC is not null");
            return (Criteria) this;
        }

        // 添加查询条件，判断COUPON_DESC是否等于某个值
        public Criteria andCouponDescEqualTo(String value) {
            addCriterion("COUPON_DESC =", value, "couponDesc");
            return (Criteria) this;
        }

        // 添加查询条件，判断COUPON_DESC是否不等于某个值
        public Criteria andCouponDescNotEqualTo(String value) {
            addCriterion("COUPON_DESC <>", value, "couponDesc");
            return (Criteria) this;
        }

        // 添加查询条件，判断COUPON_DESC是否大于某个值
        public Criteria andCouponDescGreaterThan(String value) {
            addCriterion("COUPON_DESC >", value, "couponDesc");
            return (Criteria) this;
        }

        // 添加查询条件，判断COUPON_DESC是否大于等于某个值
        public Criteria andCouponDescGreaterThanOrEqualTo(String value) {
            addCriterion("COUPON_DESC >=", value, "couponDesc");
            return (Criteria) this;
        }

        // 添加查询条件，判断COUPON_DESC是否小于某个值
        public Criteria andCouponDescLessThan(String value) {
            addCriterion("COUPON_DESC <", value, "couponDesc");
            return (Criteria) this;
        }

        // 添加查询条件，判断COUPON_DESC是否小于等于某个值
        public Criteria andCouponDescLessThanOrEqualTo(String value) {
            addCriterion("COUPON_DESC <=", value, "couponDesc");
            return (Criteria) this;
        }

        // 添加查询条件，判断COUPON_DESC是否包含某个值
        public Criteria andCouponDescLike(String value) {
            addCriterion("COUPON_DESC like", value, "couponDesc");
            return (Criteria) this;
        }

        // 添加查询条件，判断COUPON_DESC是否不包含某个值
        public Criteria andCouponDescNotLike(String value) {
            addCriterion("COUPON_DESC not like", value, "couponDesc");
            return (Criteria) this;
        }

        // 添加查询条件，判断COUPON_DESC是否包含某个值
        public Criteria andCouponDescIn(List<String> values) {
            addCriterion("COUPON_DESC in", values, "couponDesc");
            return (Criteria) this;
        }

        // 添加查询条件，判断COUPON_DESC是否不包含某个值
        public Criteria andCouponDescNotIn(List<String> values) {
            addCriterion("COUPON_DESC not in", values, "couponDesc");
            return (Criteria) this;
        }

        // 添加查询条件，判断COUPON_DESC是否在某个范围内
        public Criteria andCouponDescBetween(String value1, String value2) {
            addCriterion("COUPON_DESC between", value1, value2, "couponDesc");
            return (Criteria) this;
        }

        // 添加查询条件，判断COUPON_DESC是否不在某个范围内
        public Criteria andCouponDescNotBetween(String value1, String value2) {
            addCriterion("COUPON_DESC not between", value1, value2, "couponDesc");
            return (Criteria) this;
        }

        // 添加查询条件，判断IS_USED是否为空
        public Criteria andIsUsedIsNull() {
            addCriterion("IS_USED is null");
            return (Criteria) this;
        }

        // 添加查询条件，判断IS_USED是否不为空
        public Criteria andIsUsedIsNotNull() {
            addCriterion("IS_USED is not null");
            return (Criteria) this;
        }

        // 添加查询条件，判断IS_USED是否等于某个值
        public Criteria andIsUsedEqualTo(Integer value) {
            addCriterion("IS_USED =", value, "isUsed");
            return (Criteria) this;
        }

        // 添加查询条件，判断IS_USED是否不等于某个值
        public Criteria andIsUsedNotEqualTo(Integer value) {
            addCriterion("IS_USED <>", value, "isUsed");
            return (Criteria) this;
        }

        // 添加查询条件，判断IS_USED是否大于某个值
        public Criteria andIsUsedGreaterThan(Integer value) {
            addCriterion("IS_USED >", value, "isUsed");
            return (Criteria) this;
        }

        // 添加查询条件，判断IS_USED是否大于等于某个值
        public Criteria andIsUsedGreaterThanOrEqualTo(Integer value) {
            addCriterion("IS_USED >=", value, "isUsed");
            return (Criteria) this;
        }

        // 添加查询条件，判断IS_USED是否小于某个值
        public Criteria andIsUsedLessThan(Integer value) {
            addCriterion("IS_USED <", value, "isUsed");
            return (Criteria) this;
        }

        // 添加查询条件，判断IS_USED是否小于等于某个值
        public Criteria andIsUsedLessThanOrEqualTo(Integer value) {
            addCriterion("IS_USED <=", value, "isUsed");
            return (Criteria) this;
        }

        // 添加查询条件，判断IS_USED是否包含某个值
        public Criteria andIsUsedIn(List<Integer> values) {
            addCriterion("IS_USED in", values, "isUsed");
            return (Criteria) this;
        }

        // 添加查询条件，判断IS_USED是否不包含某个值
        public Criteria andIsUsedNotIn(List<Integer> values) {
            addCriterion("IS_USED not in", values, "isUsed");
            return (Criteria) this;
        }

        // 添加查询条件，判断IS_USED是否在某个范围内
        public Criteria andIsUsedBetween(Integer value1, Integer value2) {
            addCriterion("IS_USED between", value1, value2, "isUsed");
            return (Criteria) this;
        }

        // 添加查询条件，判断IS_USED是否不在某个范围内
        public Criteria andIsUsedNotBetween(Integer value1, Integer value2) {
            addCriterion("IS_USED not between", value1, value2, "isUsed");
            return (Criteria) this;
        }

        // 添加查询条件，判断IS_USEFUL是否为空
        public Criteria andIsUsefulIsNull() {
            addCriterion("IS_USEFUL is null");
            return (Criteria) this;
        }

        // 添加查询条件，判断IS_USEFUL是否不为空
        public Criteria andIsUsefulIsNotNull() {
            addCriterion("IS_USEFUL is not null");
            return (Criteria) this;
        }

        // 添加查询条件，判断IS_USEFUL是否等于某个值
        public Criteria andIsUsefulEqualTo(Integer value) {
            addCriterion("IS_USEFUL =", value, "isUseful");
            return (Criteria) this;
        }

        // 添加查询条件，判断IS_USEFUL是否不等于某个值
        public Criteria andIsUsefulNotEqualTo(Integer value) {
            addCriterion("IS_USEFUL <>", value, "isUseful");
            return (Criteria) this;
        }

        // 添加查询条件，判断IS_USEFUL是否大于某个值
        public Criteria andIsUsefulGreaterThan(Integer value) {
            addCriterion("IS_USEFUL >", value, "isUseful");
            return (Criteria) this;
        }

        // 添加查询条件，判断IS_USEFUL是否大于等于某个值
        public Criteria andIsUsefulGreaterThanOrEqualTo(Integer value) {
            addCriterion("IS_USEFUL >=", value, "isUseful");
            return (Criteria) this;
        }

        // 添加查询条件，判断IS_USEFUL是否小于某个值
        public Criteria andIsUsefulLessThan(Integer value) {
            addCriterion("IS_USEFUL <", value, "isUseful");
            return (Criteria) this;
        }

        // 添加查询条件，判断IS_USEFUL是否小于等于某个值
        public Criteria andIsUsefulLessThanOrEqualTo(Integer value) {
            addCriterion("IS_USEFUL <=", value, "isUseful");
            return (Criteria) this;
        }

        // 添加查询条件，判断IS_USEFUL是否包含某个值
        public Criteria andIsUsefulIn(List<Integer> values) {
            addCriterion("IS_USEFUL in", values, "isUseful");
            return (Criteria) this;
        }

        // 添加查询条件，判断IS_USEFUL是否不包含某个值
        public Criteria andIsUsefulNotIn(List<Integer> values) {
            addCriterion("IS_USEFUL not in", values, "isUseful");
            return (Criteria) this;
        }

        // 添加查询条件，判断IS_USEFUL是否在某个范围内
        public Criteria andIsUsefulBetween(Integer value1, Integer value2) {
            addCriterion("IS_USEFUL between", value1, value2, "isUseful");
            return (Criteria) this;
        }

        // 添加查询条件，判断IS_USEFUL是否不在某个范围内
        public Criteria andIsUsefulNotBetween(Integer value1, Integer value2) {
            addCriterion("IS_USEFUL not between", value1, value2, "isUseful");
            return (Criteria) this;
        }

        // 添加查询条件，判断IS_GIFT是否为空
        public Criteria andIsGiftIsNull() {
            addCriterion("IS_GIFT is null");
            return (Criteria) this;
        }

        // 添加查询条件，判断IS_GIFT是否不为空
        public Criteria andIsGiftIsNotNull() {
            addCriterion("IS_GIFT is not null");
            return (Criteria) this;
        }

        // 添加查询条件，判断IS_GIFT是否等于某个值
        public Criteria andIsGiftEqualTo(Integer value) {
            addCriterion("IS_GIFT =", value, "isGift");
            return (Criteria) this;
        }

        // 添加查询条件，判断IS_GIFT是否不等于某个值
        public Criteria andIsGiftNotEqualTo(Integer value) {
            addCriterion("IS_GIFT <>", value, "isGift");
            return (Criteria) this;
        }

        // 添加查询条件，判断IS_GIFT是否大于某个值
        public Criteria andIsGiftGreaterThan(Integer value) {
            addCriterion("IS_GIFT >", value, "isGift");
            return (Criteria) this;
        }

        // 添加查询条件，判断IS_GIFT是否大于等于某个值
        public Criteria andIsGiftGreaterThanOrEqualTo(Integer value) {
            addCriterion("IS_GIFT >=", value, "isGift");
            return (Criteria) this;
        }

        // 添加查询条件，判断IS_GIFT是否小于某个值
        public Criteria andIsGiftLessThan(Integer value) {
            addCriterion("IS_GIFT <", value, "isGift");
            return (Criteria) this;
        }

        // 添加查询条件，判断IS_GIFT是否小于等于某个值
        public Criteria andIsGiftLessThanOrEqualTo(Integer value) {
            addCriterion("IS_GIFT <=", value, "isGift");
            return (Criteria) this;
        }

        // 添加查询条件，判断IS_GIFT是否包含某个值
        public Criteria andIsGiftIn(List<Integer> values) {
            addCriterion("IS_GIFT in", values, "isGift");
            return (Criteria) this;
        }

        // 添加查询条件，判断IS_GIFT是否不包含某个值
        public Criteria andIsGiftNotIn(List<Integer> values) {
            addCriterion("IS_GIFT not in", values, "isGift");
            return (Criteria) this;
        }

        // 添加查询条件，判断IS_GIFT是否在某个范围内
        public Criteria andIsGiftBetween(Integer value1, Integer value2) {
            addCriterion("IS_GIFT between", value1, value2, "isGift");
            return (Criteria) this;
        }

        // 添加查询条件，判断IS_GIFT是否不在某个范围内
        public Criteria andIsGiftNotBetween(Integer value1, Integer value2) {
            addCriterion("IS_GIFT not between", value1, value2, "isGift");
            return (Criteria) this;
        }

        // 添加查询条件，判断IS_SEND是否为空
        public Criteria andIsSendIsNull() {
            addCriterion("IS_SEND is null");
            return (Criteria) this;
        }

        // 添加查询条件，判断IS_SEND是否不为空
        public Criteria andIsSendIsNotNull() {
            addCriterion("IS_SEND is not null");
            return (Criteria) this;
        }

        // 添加查询条件，判断IS_SEND是否等于某个值
        public Criteria andIsSendEqualTo(Integer value) {
            addCriterion("IS_SEND =", value, "isSend");
            return (Criteria) this;
        }

        // 添加查询条件，判断IS_SEND是否不等于某个值
        public Criteria andIsSendNotEqualTo(Integer value) {
            addCriterion("IS_SEND <>", value, "isSend");
            return (Criteria) this;
        }

        // 添加查询条件，判断IS_SEND是否大于某个值
        public Criteria andIsSendGreaterThan(Integer value) {
            addCriterion("IS_SEND >", value, "isSend");
            return (Criteria) this;
        }

        // 添加查询条件，判断IS_SEND是否大于等于某个值
        public Criteria andIsSendGreaterThanOrEqualTo(Integer value) {
            addCriterion("IS_SEND >=", value, "isSend");
            return (Criteria) this;
        }

        // 添加查询条件，判断IS_SEND是否小于某个值
        public Criteria andIsSendLessThan(Integer value) {
            addCriterion("IS_SEND <", value, "isSend");
            return (Criteria) this;
        }

        // 添加查询条件，判断IS_SEND是否小于等于某个值
        public Criteria andIsSendLessThanOrEqualTo(Integer value) {
            addCriterion("IS_SEND <=", value, "isSend");
            return (Criteria) this;
        }

        // 添加查询条件，判断IS_SEND是否包含某个值
        public Criteria andIsSendIn(List<Integer> values) {
            addCriterion("IS_SEND in", values, "isSend");
            return (Criteria) this;
        }

        // 添加查询条件，判断IS_SEND是否不包含某个值
        public Criteria andIsSendNotIn(List<Integer> values) {
            addCriterion("IS_SEND not in", values, "isSend");
            return (Criteria) this;
        }

        // 添加查询条件，判断IS_SEND是否在某个范围内
        public Criteria andIsSendBetween(Integer value1, Integer value2) {
            addCriterion("IS_SEND between", value1, value2, "isSend");
            return (Criteria) this;
        }

        // 添加查询条件，判断IS_SEND是否不在某个范围内
        public Criteria andIsSendNotBetween(Integer value1, Integer value2) {
            addCriterion("IS_SEND not between", value1, value2, "isSend");
            return (Criteria) this;
        }

        // 添加查询条件，判断PAYMENT_TYPE是否为空
        public Criteria andPaymentTypeIsNull() {
            addCriterion("PAYMENT_TYPE is null");
            return (Criteria) this;
        }

        // 添加查询条件，判断PAYMENT_TYPE是否不为空
        public Criteria andPaymentTypeIsNotNull() {
            addCriterion("PAYMENT_TYPE is not null");
            return (Criteria) this;
        }

        // 添加查询条件，判断PAYMENT_TYPE是否等于某个值
        public Criteria andPaymentTypeEqualTo(Integer value) {
            addCriterion("PAYMENT_TYPE =", value, "paymentType");
            return (Criteria) this;
        }

        // 添加查询条件，判断PAYMENT_TYPE是否不等于某个值
        public Criteria andPaymentTypeNotEqualTo(Integer value) {
            addCriterion("PAYMENT_TYPE <>", value, "paymentType");
            return (Criteria) this;
        }

        // 添加查询条件，判断PAYMENT_TYPE是否大于某个值
        public Criteria andPaymentTypeGreaterThan(Integer value) {
            addCriterion("PAYMENT_TYPE >", value, "paymentType");
            return (Criteria) this;
        }

        // 添加查询条件，判断PAYMENT_TYPE是否大于等于某个值
        public Criteria andPaymentTypeGreaterThanOrEqualTo(Integer value) {
            addCriterion("PAYMENT_TYPE >=", value, "paymentType");
            return (Criteria) this;
        }

        // 添加查询条件，判断PAYMENT_TYPE是否小于某个值
        public Criteria andPaymentTypeLessThan(Integer value) {
            addCriterion("PAYMENT_TYPE <", value, "paymentType");
            return (Criteria) this;
        }

        // 添加查询条件，判断PAYMENT_TYPE是否小于等于某个值
        public Criteria andPaymentTypeLessThanOrEqualTo(Integer value) {
            addCriterion("PAYMENT_TYPE <=", value, "paymentType");
            return (Criteria) this;
        }

        // 添加查询条件，判断PAYMENT_TYPE是否包含某个值
        public Criteria andPaymentTypeIn(List<Integer> values) {
            addCriterion("PAYMENT_TYPE in", values, "paymentType");
            return (Criteria) this;
        }

        // 添加查询条件，判断PAYMENT_TYPE是否不包含某个值
        public Criteria andPaymentTypeNotIn(List<Integer> values) {
            addCriterion("PAYMENT_TYPE not in", values, "paymentType");
            return (Criteria) this;
        }

        // 添加查询条件，判断PAYMENT_TYPE是否在某个范围内
        public Criteria andPaymentTypeBetween(Integer value1, Integer value2) {
            addCriterion("PAYMENT_TYPE between", value1, value2, "paymentType");
            return (Criteria) this;
        }

        // 添加查询条件，判断PAYMENT_TYPE是否不在某个范围内
        public Criteria andPaymentTypeNotBetween(Integer value1, Integer value2) {
            addCriterion("PAYMENT_TYPE not between", value1, value2, "paymentType");
            return (Criteria) this;
        }

        // 添加查询条件，判断BEGIN_TIME是否为空
        public Criteria andBeginTimeIsNull() {
            addCriterion("BEGIN_TIME is null");
            return (Criteria) this;
        }

        // 添加查询条件，判断BEGIN_TIME是否不为空
        public Criteria andBeginTimeIsNotNull() {
            addCriterion("BEGIN_TIME is not null");
            return (Criteria) this;
        }

        // 添加查询条件，判断BEGIN_TIME是否等于某个值
        public Criteria andBeginTimeEqualTo(Date value) {
            addCriterion("BEGIN_TIME =", value, "beginTime");
            return (Criteria) this;
        }

        // 添加查询条件，判断BEGIN_TIME是否不等于某个值
        public Criteria andBeginTimeNotEqualTo(Date value) {
            addCriterion("BEGIN_TIME <>", value, "beginTime");
            return (Criteria) this;
        }

        // 添加查询条件，判断BEGIN_TIME是否大于某个值
        public Criteria andBeginTimeGreaterThan(Date value) {
            addCriterion("BEGIN_TIME >", value, "beginTime");
            return (Criteria) this;
        }

        // 添加查询条件，判断BEGIN_TIME是否大于等于某个值
        public Criteria andBeginTimeGreaterThanOrEqualTo(Date value) {
            addCriterion("BEGIN_TIME >=", value, "beginTime");
            return (Criteria) this;
        }

        // 添加查询条件，判断BEGIN_TIME是否小于某个值
        public Criteria andBeginTimeLessThan(Date value) {
            addCriterion("BEGIN_TIME <", value, "beginTime");
            return (Criteria) this;
        }

        // 添加查询条件，判断BEGIN_TIME是否小于等于某个值
        public Criteria andBeginTimeLessThanOrEqualTo(Date value) {
            addCriterion("BEGIN_TIME <=", value, "beginTime");
            return (Criteria) this;
        }

        // 添加查询条件，判断BEGIN_TIME是否包含某个值
        public Criteria andBeginTimeIn(List<Date> values) {
            addCriterion("BEGIN_TIME in", values, "beginTime");
            return (Criteria) this;
        }

        // 添加查询条件，判断BEGIN_TIME是否不包含某个值
        public Criteria andBeginTimeNotIn(List<Date> values) {
            addCriterion("BEGIN_TIME not in", values, "beginTime");
            return (Criteria) this;
        }

        // 添加查询条件，判断BEGIN_TIME是否在某个范围内
        public Criteria andBeginTimeBetween(Date value1, Date value2) {
            addCriterion("BEGIN_TIME between", value1, value2, "beginTime");
            return (Criteria) this;
        }

        // 添加查询条件，判断BEGIN_TIME是否不在某个范围内
        public Criteria andBeginTimeNotBetween(Date value1, Date value2) {
            addCriterion("BEGIN_TIME not between", value1, value2, "beginTime");
            return (Criteria) this;
        }

        // 添加查询条件，判断END_TIME是否为空
        public Criteria andEndTimeIsNull() {
            addCriterion("END_TIME is null");
            return (Criteria) this;
        }

        // 添加查询条件，判断END_TIME是否不为空
        public Criteria andEndTimeIsNotNull() {
            addCriterion("END_TIME is not null");
            return (Criteria) this;
        }

        // 添加查询条件，判断END_TIME是否等于某个值
        public Criteria andEndTimeEqualTo(Date value) {
            addCriterion("END_TIME =", value, "endTime");
            return (Criteria) this;
        }

        // 添加查询条件，判断END_TIME是否不等于某个值
        public Criteria andEndTimeNotEqualTo(Date value) {
            addCriterion("END_TIME <>", value, "endTime");
            return (Criteria) this;
        }

        // 添加查询条件，判断END_TIME是否大于某个值
        public Criteria andEndTimeGreaterThan(Date value) {
            addCriterion("END_TIME >", value, "endTime");
            return (Criteria) this;
        }

        // 添加查询条件，判断END_TIME是否大于等于某个值
        public Criteria andEndTimeGreaterThanOrEqualTo(Date value) {
            addCriterion("END_TIME >=", value, "endTime");
            return (Criteria) this;
        }

        // 添加查询条件，判断END_TIME是否小于某个值
        public Criteria andEndTimeLessThan(Date value) {
            addCriterion("END_TIME <", value, "endTime");
            return (Criteria) this;
        }

        // 添加查询条件，判断END_TIME是否小于等于某个值
        public Criteria andEndTimeLessThanOrEqualTo(Date value) {
            addCriterion("END_TIME <=", value, "endTime");
            return (Criteria) this;
        }

        // 添加查询条件，判断END_TIME是否包含某个值
        public Criteria andEndTimeIn(List<Date> values) {
            addCriterion("END_TIME in", values, "endTime");
            return (Criteria) this;
        }

        // 添加查询条件，判断END_TIME是否不包含某个值
        public Criteria andEndTimeNotIn(List<Date> values) {
            addCriterion("END_TIME not in", values, "endTime");
            return (Criteria) this;
        }

        // 添加查询条件，判断END_TIME是否在某个范围内
        public Criteria andEndTimeBetween(Date value1, Date value2) {
            addCriterion("END_TIME between", value1, value2, "endTime");
            return (Criteria) this;
        }

        // 添加查询条件，判断END_TIME是否不在某个范围内
        public Criteria andEndTimeNotBetween(Date value1, Date value2) {
            addCriterion("END_TIME not between", value1, value2, "endTime");
            return (Criteria) this;
        }

        // 添加查询条件，判断NOTES是否为空
        public Criteria andNotesIsNull() {
            addCriterion("NOTES is null");
            return (Criteria) this;
        }

        // 添加查询条件，判断NOTES是否不为空
        public Criteria andNotesIsNotNull() {
            addCriterion("NOTES is not null");
            return (Criteria) this;
        }

        // 添加查询条件，判断NOTES是否等于某个值
        public Criteria andNotesEqualTo(String value) {
            addCriterion("NOTES =", value, "notes");
            return (Criteria) this;
        }

        // 添加查询条件，判断NOTES是否不等于某个值
        public Criteria andNotesNotEqualTo(String value) {
            addCriterion("NOTES <>", value, "notes");
            return (Criteria) this;
        }

        // 添加查询条件，判断NOTES是否大于某个值
        public Criteria andNotesGreaterThan(String value) {
            addCriterion("NOTES >", value, "notes");
            return (Criteria) this;
        }

        // 添加查询条件，判断NOTES是否大于等于某个值
        public Criteria andNotesGreaterThanOrEqualTo(String value) {
            addCriterion("NOTES >=", value, "notes");
            return (Criteria) this;
        }

        // 添加查询条件，判断NOTES是否小于某个值
        public Criteria andNotesLessThan(String value) {
            addCriterion("NOTES <", value, "notes");
            return (Criteria) this;
        }

        // 添加查询条件，判断NOTES是否小于等于某个值
        public Criteria andNotesLessThanOrEqualTo(String value) {
            addCriterion("NOTES <=", value, "notes");
            return (Criteria) this;
        }

        // 添加查询条件，判断NOTES是否包含某个值
        public Criteria andNotesLike(String value) {
            addCriterion("NOTES like", value, "notes");
            return (Criteria) this;
        }

        // 添加查询条件，判断NOTES是否不包含某个值
        public Criteria andNotesNotLike(String value) {
            addCriterion("NOTES not like", value, "notes");
            return (Criteria) this;
        }

        // 添加查询条件，判断NOTES是否包含某个值
        public Criteria andNotesIn(List<String> values) {
            addCriterion("NOTES in", values, "notes");
            return (Criteria) this;
        }

        // 添加查询条件，判断NOTES是否不包含某个值
        public Criteria andNotesNotIn(List<String> values) {
            addCriterion("NOTES not in", values, "notes");
            return (Criteria) this;
        }

        // 添加查询条件，判断NOTES是否在某个范围内
        public Criteria andNotesBetween(String value1, String value2) {
            addCriterion("NOTES between", value1, value2, "notes");
            return (Criteria) this;
        }

        // 添加查询条件，判断NOTES是否不在某个范围内
        public Criteria andNotesNotBetween(String value1, String value2) {
            addCriterion("NOTES not between", value1, value2, "notes");
            return (Criteria) this;
        }

        // 添加查询条件，判断IS_OVER是否为空
        public Criteria andIsOverIsNull() {
            addCriterion("IS_OVER is null");
            return (Criteria) this;
        }

        // 添加查询条件，判断IS_OVER是否不为空
        public Criteria andIsOverIsNotNull() {
            addCriterion("IS_OVER is not null");
            return (Criteria) this;
        }

        // 添加查询条件，判断IS_OVER是否等于某个值
        public Criteria andIsOverEqualTo(Integer value) {
            addCriterion("IS_OVER =", value, "isOver");
            return (Criteria) this;
        }

        // 添加查询条件，判断IS_OVER是否不等于某个值
        public Criteria andIsOverNotEqualTo(Integer value) {
            addCriterion("IS_OVER <>", value, "isOver");
            return (Criteria) this;
        }

        // 添加查询条件，判断IS_OVER是否大于某个值
        public Criteria andIsOverGreaterThan(Integer value) {
            addCriterion("IS_OVER >", value, "isOver");
            return (Criteria) this;
        }

        // 添加查询条件，判断IS_OVER是否大于等于某个值
        public Criteria andIsOverGreaterThanOrEqualTo(Integer value) {
            addCriterion("IS_OVER >=", value, "isOver");
            return (Criteria) this;
        }

        // 添加查询条件，判断IS_OVER是否小于某个值
        public Criteria andIsOverLessThan(Integer value) {
            addCriterion("IS_OVER <", value, "isOver");
            return (Criteria) this;
        }

        // 添加查询条件，判断IS_OVER是否小于等于某个值
        public Criteria andIsOverLessThanOrEqualTo(Integer value) {
            addCriterion("IS_OVER <=", value, "isOver");
            return (Criteria) this;
        }

        // 添加查询条件，判断IS_OVER是否包含某个值
        public Criteria andIsOverIn(List<Integer> values) {
            addCriterion("IS_OVER in", values, "isOver");
            return (Criteria) this;
        }

        // 添加查询条件，判断IS_OVER是否不包含某个值
        public Criteria andIsOverNotIn(List<Integer> values) {
            addCriterion("IS_OVER not in", values, "isOver");
            return (Criteria) this;
        }

        // 添加查询条件，判断IS_OVER是否在某个范围内
        public Criteria andIsOverBetween(Integer value1, Integer value2) {
            addCriterion("IS_OVER between", value1, value2, "isOver");
            return (Criteria) this;
        }

        // 添加查询条件，判断IS_OVER是否不在某个范围内
        public Criteria andIsOverNotBetween(Integer value1, Integer value2) {
            addCriterion("IS_OVER not between", value1, value2, "isOver");
            return (Criteria) this;
        }

        // 添加查询条件，判断AUDIT_DATE是否为空
        public Criteria andAuditDateIsNull() {
            addCriterion("AUDIT_DATE is null");
            return (Criteria) this;
        }

        // 添加查询条件，判断AUDIT_DATE是否不为空
        public Criteria andAuditDateIsNotNull() {
            addCriterion("AUDIT_DATE is not null");
            return (Criteria) this;
        }

        // 添加查询条件，判断AUDIT_DATE是否等于某个值
        public Criteria andAuditDateEqualTo(Date value) {
            addCriterion("AUDIT_DATE =", value, "auditDate");
            return (Criteria) this;
        }

        // 添加查询条件，判断AUDIT_DATE是否不等于某个值
        public Criteria andAuditDateNotEqualTo(Date value) {
            addCriterion("AUDIT_DATE <>", value, "auditDate");
            return (Criteria) this;
        }

        // 添加查询条件，判断AUDIT_DATE是否大于某个值
        public Criteria andAuditDateGreaterThan(Date value) {
            addCriterion("AUDIT_DATE >", value, "auditDate");
            return (Criteria) this;
        }

        // 添加查询条件，判断AUDIT_DATE是否大于等于某个值
        public Criteria andAuditDateGreaterThanOrEqualTo(Date value) {
            addCriterion("AUDIT_DATE >=", value, "auditDate");
            return (Criteria) this;
        }

        // 添加查询条件，判断AUDIT_DATE是否小于某个值
        public Criteria andAuditDateLessThan(Date value) {
            addCriterion("AUDIT_DATE <", value, "auditDate");
            return (Criteria) this;
        }

        // 添加查询条件，判断AUDIT_DATE是否小于等于某个值
        public Criteria andAuditDateLessThanOrEqualTo(Date value) {
            addCriterion("AUDIT_DATE <=", value, "auditDate");
            return (Criteria) this;
        }

        // 添加查询条件，判断AUDIT_DATE是否包含某个值
        public Criteria andAuditDateIn(List<Date> values) {
            addCriterion("AUDIT_DATE in", values, "auditDate");
            return (Criteria) this;
        }

        // 添加查询条件，判断AUDIT_DATE是否不包含某个值
        public Criteria andAuditDateNotIn(List<Date> values) {
            addCriterion("AUDIT_DATE not in", values, "auditDate");
            return (Criteria) this;
        }

        // 添加查询条件，判断AUDIT_DATE是否在某个范围内
        public Criteria andAuditDateBetween(Date value1, Date value2) {
            addCriterion("AUDIT_DATE between", value1, value2, "auditDate");
            return (Criteria) this;
        }

        // 添加查询条件，判断AUDIT_DATE是否不在某个范围内
        public Criteria andAuditDateNotBetween(Date value1, Date value2) {
            addCriterion("AUDIT_DATE not between", value1, value2, "auditDate");
            return (Criteria) this;
        }

        // 添加查询条件，判断BATCH是否为空
        public Criteria andBatchIsNull() {
            addCriterion("BATCH is null");
            return (Criteria) this;
        }

        // 添加查询条件，判断BATCH是否不为空
        public Criteria andBatchIsNotNull() {
            addCriterion("BATCH is not null");
            return (Criteria) this;
        }

        // 添加查询条件，判断BATCH是否等于某个值
        public Criteria andBatchEqualTo(String value) {
            addCriterion("BATCH =", value, "batch");
            return (Criteria) this;
        }

        // 添加查询条件，判断BATCH是否不等于某个值
        public Criteria andBatchNotEqualTo(String value) {
            addCriterion("BATCH <>", value, "batch");
            return (Criteria) this;
        }

        // 添加查询条件，判断BATCH是否大于某个值
        public Criteria andBatchGreaterThan(String value) {
            addCriterion("BATCH >", value, "batch");
            return (Criteria) this;
        }

        // 添加查询条件，判断BATCH是否大于等于某个值
        public Criteria andBatchGreaterThanOrEqualTo(String value) {
            addCriterion("BATCH >=", value, "batch");
            return (Criteria) this;
        }

        // 添加查询条件，判断BATCH是否小于某个值
        public Criteria andBatchLessThan(String value) {
            addCriterion("BATCH <", value, "batch");
            return (Criteria) this;
        }

        // 添加查询条件，判断BATCH是否小于等于某个值
        public Criteria andBatchLessThanOrEqualTo(String value) {
            addCriterion("BATCH <=", value, "batch");
            return (Criteria) this;
        }

        // 添加查询条件，判断BATCH是否包含某个值
        public Criteria andBatchLike(String value) {
            addCriterion("BATCH like", value, "batch");
            return (Criteria) this;
        }

        // 添加查询条件，判断BATCH是否不包含某个值
        public Criteria andBatchNotLike(String value) {
            addCriterion("BATCH not like", value, "batch");
            return (Criteria) this;
        }

        // 添加查询条件，判断BATCH是否包含在某个集合中
        public Criteria andBatchIn(List<String> values) {
            addCriterion("BATCH in", values, "batch");
            return (Criteria) this;
        }

        // 添加查询条件，判断BATCH是否不包含在某个集合中
        public Criteria andBatchNotIn(List<String> values) {
            addCriterion("BATCH not in", values, "batch");
            return (Criteria) this;
        }

        // 添加查询条件，判断BATCH是否在某个范围内
        public Criteria andBatchBetween(String value1, String value2) {
            addCriterion("BATCH between", value1, value2, "batch");
            return (Criteria) this;
        }

        // 添加查询条件，判断BATCH是否不在某个范围内
        public Criteria andBatchNotBetween(String value1, String value2) {
            addCriterion("BATCH not between", value1, value2, "batch");
            return (Criteria) this;
        }

        // 添加查询条件，判断COUPON_CODE是否为空
        public Criteria andUsefulDateIsNull() {
            addCriterion("USEFUL_DATE is null");
            return (Criteria) this;
        }

        // 添加查询条件，判断COUPON_CODE是否不为空
        public Criteria andUsefulDateIsNotNull() {
            addCriterion("USEFUL_DATE is not null");
            return (Criteria) this;
        }

        // 添加查询条件，判断COUPON_CODE是否等于某个值
        public Criteria andUsefulDateEqualTo(Date value) {
            addCriterion("USEFUL_DATE =", value, "usefulDate");
            return (Criteria) this;
        }

        // 添加查询条件，判断COUPON_CODE是否不等于某个值
        public Criteria andUsefulDateNotEqualTo(Date value) {
            addCriterion("USEFUL_DATE <>", value, "usefulDate");
            return (Criteria) this;
        }

        // 添加查询条件，判断COUPON_CODE是否大于某个值
        public Criteria andUsefulDateGreaterThan(Date value) {
            addCriterion("USEFUL_DATE >", value, "usefulDate");
            return (Criteria) this;
        }

        // 添加查询条件，判断COUPON_CODE是否大于等于某个值
        public Criteria andUsefulDateGreaterThanOrEqualTo(Date value) {
            addCriterion("USEFUL_DATE >=", value, "usefulDate");
            return (Criteria) this;
        }

        // 添加查询条件，判断COUPON_CODE是否小于某个值
        public Criteria andUsefulDateLessThan(Date value) {
            addCriterion("USEFUL_DATE <", value, "usefulDate");
            return (Criteria) this;
        }

        // 添加查询条件，判断COUPON_CODE是否小于等于某个值
        public Criteria andUsefulDateLessThanOrEqualTo(Date value) {
            addCriterion("USEFUL_DATE <=", value, "usefulDate");
            return (Criteria) this;
        }

        // 添加查询条件，判断COUPON_CODE是否包含某个值
        public Criteria andUsefulDateIn(List<Date> values) {
            addCriterion("USEFUL_DATE in", values, "usefulDate");
            return (Criteria) this;
        }

        // 添加查询条件，判断COUPON_CODE是否不包含某个值
        public Criteria andUsefulDateNotIn(List<Date> values) {
            addCriterion("USEFUL_DATE not in", values, "usefulDate");
            return (Criteria) this;
        }

        // 添加查询条件，判断COUPON_CODE是否在某个范围内
        public Criteria andUsefulDateBetween(Date value1, Date value2) {
            addCriterion("USEFUL_DATE between", value1, value2, "usefulDate");
            return (Criteria) this;
        }

        // 添加查询条件，判断COUPON_CODE是否不在某个范围内
        public Criteria andUsefulDateNotBetween(Date value1, Date value2) {
            addCriterion("USEFUL_DATE not between", value1, value2, "usefulDate");
            return (Criteria) this;
        }
    }

    public static class Criteria extends GeneratedCriteria {

        protected Criteria() {
            super();
        }
    }

    public static class Criterion {
        private String condition;

        private Object value;

        private Object secondValue;

        private boolean noValue;

        private boolean singleValue;

        private boolean betweenValue;

        private boolean listValue;

        private String typeHandler;

        public String getCondition() {
            return condition;
        }

        public Object getValue() {
            return value;
        }

        public Object getSecondValue() {
            return secondValue;
        }

        public boolean isNoValue() {
            return noValue;
        }

        public boolean isSingleValue() {
            return singleValue;
        }

        public boolean isBetweenValue() {
            return betweenValue;
        }

        public boolean isListValue() {
            return listValue;
        }

        public String getTypeHandler() {
            return typeHandler;
        }

        protected Criterion(String condition) {
            super();
            this.condition = condition;
            this.typeHandler = null;
            this.noValue = true;
        }

        protected Criterion(String condition, Object value, String typeHandler) {
            super();
            this.condition = condition;
            this.value = value;
            this.typeHandler = typeHandler;
            if (value instanceof List<?>) {
                this.listValue = true;
            } else {
                this.singleValue = true;
            }
        }

        protected Criterion(String condition, Object value) {
            this(condition, value, null);
        }

        protected Criterion(String condition, Object value, Object secondValue, String typeHandler) {
            super();
            this.condition = condition;
            this.value = value;
            this.secondValue = secondValue;
            this.typeHandler = typeHandler;
            this.betweenValue = true;
        }

        protected Criterion(String condition, Object value, Object secondValue) {
            this(condition, value, secondValue, null);
        }
    }
}