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;

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

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

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

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

    // 设置orderByClause变量的值
    public void setOrderByClause(String orderByClause) {
        this.orderByClause = orderByClause;
    }

    // 获取orderByClause变量的值
    public String getOrderByClause() {
        return orderByClause;
    }

    // 设置distinct变量的值
    public void setDistinct(boolean distinct) {
        this.distinct = distinct;
    }

    // 获取distinct变量的值
    public boolean isDistinct() {
        return distinct;
    }

    // 获取oredCriteria变量的值
    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;
    }

    // 清空oredCriteria变量和orderByClause变量以及distinct变量的值
    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>();
        }

        // 判断criteria变量是否为空
        public boolean isValid() {
            return criteria.size() > 0;
        }

        // 获取criteria变量的值
        public List<Criterion> getAllCriteria() {
            return criteria;
        }

        // 获取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;
        }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        // 添加一个查询条件，判断BASE_PRICE是否在某个范围内
        public Criteria andBasePriceIn(List<BigDecimal> values) {
            addCriterion("BASE_PRICE in", values, "basePrice");
            return (Criteria) this;
        }

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

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

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

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

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

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

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

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

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

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

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

        // 添加一个查询条件，判断MEMBER_PRICE是否在某个范围内
        public Criteria andMemberPriceIn(List<BigDecimal> values) {
            addCriterion("MEMBER_PRICE in", values, "memberPrice");
            return (Criteria) this;
        }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        // 添加SELL_STATUS大于等于value的条件
        public Criteria andSellStatusGreaterThanOrEqualTo(Integer value) {
            addCriterion("SELL_STATUS >=", value, "sellStatus");
            return (Criteria) this;
        }

        // 添加SELL_STATUS小于value的条件
        public Criteria andSellStatusLessThan(Integer value) {
            addCriterion("SELL_STATUS <", value, "sellStatus");
            return (Criteria) this;
        }

        // 添加SELL_STATUS小于等于value的条件
        public Criteria andSellStatusLessThanOrEqualTo(Integer value) {
            addCriterion("SELL_STATUS <=", value, "sellStatus");
            return (Criteria) this;
        }

        // 添加SELL_STATUS在values列表中的条件
        public Criteria andSellStatusIn(List<Integer> values) {
            addCriterion("SELL_STATUS in", values, "sellStatus");
            return (Criteria) this;
        }

        // 添加SELL_STATUS不在values列表中的条件
        public Criteria andSellStatusNotIn(List<Integer> values) {
            addCriterion("SELL_STATUS not in", values, "sellStatus");
            return (Criteria) this;
        }

        public Criteria andSellStatusBetween(Integer value1, Integer value2) {
            // 添加SELL_STATUS between条件
            addCriterion("SELL_STATUS between", value1, value2, "sellStatus");
            return (Criteria) this;
        }

        public Criteria andSellStatusNotBetween(Integer value1, Integer value2) {
            // 添加SELL_STATUS not between条件
            addCriterion("SELL_STATUS not between", value1, value2, "sellStatus");
            return (Criteria) this;
        }

        public Criteria andSellUnitIsNull() {
            // 添加SELL_UNIT is null条件
            addCriterion("SELL_UNIT is null");
            return (Criteria) this;
        }

        public Criteria andSellUnitIsNotNull() {
            // 添加SELL_UNIT is not null条件
            addCriterion("SELL_UNIT is not null");
            return (Criteria) this;
        }

        public Criteria andSellUnitEqualTo(String value) {
            // 添加SELL_UNIT = value条件
            addCriterion("SELL_UNIT =", value, "sellUnit");
            return (Criteria) this;
        }

        public Criteria andSellUnitNotEqualTo(String value) {
            // 添加SELL_UNIT <> value条件
            addCriterion("SELL_UNIT <>", value, "sellUnit");
            return (Criteria) this;
        }

        public Criteria andSellUnitGreaterThan(String value) {
            // 添加SELL_UNIT > value条件
            addCriterion("SELL_UNIT >", value, "sellUnit");
            return (Criteria) this;
        }

        public Criteria andSellUnitGreaterThanOrEqualTo(String value) {
            // 添加SELL_UNIT >= value条件
            addCriterion("SELL_UNIT >=", value, "sellUnit");
            return (Criteria) this;
        }

        public Criteria andSellUnitLessThan(String value) {
            // 添加SELL_UNIT < value条件
            addCriterion("SELL_UNIT <", value, "sellUnit");
            return (Criteria) this;
        }

        public Criteria andSellUnitLessThanOrEqualTo(String value) {
            // 添加SELL_UNIT <= value条件
            addCriterion("SELL_UNIT <=", value, "sellUnit");
            return (Criteria) this;
        }

        public Criteria andSellUnitLike(String value) {
            // 添加SELL_UNIT like value条件
            addCriterion("SELL_UNIT like", value, "sellUnit");
            return (Criteria) this;
        }

        public Criteria andSellUnitNotLike(String value) {
            // 添加SELL_UNIT not like value条件
            addCriterion("SELL_UNIT not like", value, "sellUnit");
            return (Criteria) this;
        }

        public Criteria andSellUnitIn(List<String> values) {
            // 添加SELL_UNIT in values条件
            addCriterion("SELL_UNIT in", values, "sellUnit");
            return (Criteria) this;
        }

        public Criteria andSellUnitNotIn(List<String> values) {
            // 添加SELL_UNIT not in values条件
            addCriterion("SELL_UNIT not in", values, "sellUnit");
            return (Criteria) this;
        }

        public Criteria andSellUnitBetween(String value1, String value2) {
            // 添加SELL_UNIT between value1 and value2条件
            addCriterion("SELL_UNIT between", value1, value2, "sellUnit");
            return (Criteria) this;
        }

        public Criteria andSellUnitNotBetween(String value1, String value2) {
            // 添加SELL_UNIT not between value1 and value2条件
            addCriterion("SELL_UNIT not between", value1, value2, "sellUnit");
            return (Criteria) this;
        }

        public Criteria andSellPriceIsNull() {
            // 添加SELL_PRICE is null条件
            addCriterion("SELL_PRICE is null");
            return (Criteria) this;
        }

        public Criteria andSellPriceIsNotNull() {
            // 添加SELL_PRICE is not null条件
            addCriterion("SELL_PRICE is not null");
            return (Criteria) this;
        }

        public Criteria andSellPriceEqualTo(BigDecimal value) {
            // 添加SELL_PRICE = value条件
            addCriterion("SELL_PRICE =", value, "sellPrice");
            return (Criteria) this;
        }

        public Criteria andSellPriceNotEqualTo(BigDecimal value) {
            // 添加SELL_PRICE <> value条件
            addCriterion("SELL_PRICE <>", value, "sellPrice");
            return (Criteria) this;
        }

        public Criteria andSellPriceGreaterThan(BigDecimal value) {
            // 添加SELL_PRICE > value条件
            addCriterion("SELL_PRICE >", value, "sellPrice");
            return (Criteria) this;
        }

        public Criteria andSellPriceGreaterThanOrEqualTo(BigDecimal value) {
            // 添加SELL_PRICE >= value条件
            addCriterion("SELL_PRICE >=", value, "sellPrice");
            return (Criteria) this;
        }

        public Criteria andSellPriceLessThan(BigDecimal value) {
            // 添加SELL_PRICE < value条件
            addCriterion("SELL_PRICE <", value, "sellPrice");
            return (Criteria) this;
        }

        public Criteria andSellPriceLessThanOrEqualTo(BigDecimal value) {
            // 添加SELL_PRICE <= value条件
            addCriterion("SELL_PRICE <=", value, "sellPrice");
            return (Criteria) this;
        }

        public Criteria andSellPriceIn(List<BigDecimal> values) {
            // 添加SELL_PRICE in values条件
            addCriterion("SELL_PRICE in", values, "sellPrice");
            return (Criteria) this;
        }

        public Criteria andSellPriceNotIn(List<BigDecimal> values) {
            // 添加SELL_PRICE not in values条件
            addCriterion("SELL_PRICE not in", values, "sellPrice");
            return (Criteria) this;
        }

        public Criteria andSellPriceBetween(BigDecimal value1, BigDecimal value2) {
            // 添加SELL_PRICE between value1 and value2条件
            addCriterion("SELL_PRICE between", value1, value2, "sellPrice");
            return (Criteria) this;
        }

        public Criteria andSellPriceNotBetween(BigDecimal value1, BigDecimal value2) {
            // 添加SELL_PRICE not between value1 and value2条件
            addCriterion("SELL_PRICE not between", value1, value2, "sellPrice");
            return (Criteria) this;
        }

        public Criteria andIsAuditIsNull() {
            // 添加IS_AUDIT is null条件
            addCriterion("IS_AUDIT is null");
            return (Criteria) this;
        }

        public Criteria andIsAuditIsNotNull() {
            // 添加IS_AUDIT is not null条件
            addCriterion("IS_AUDIT is not null");
            return (Criteria) this;
        }

        public Criteria andIsAuditEqualTo(Integer value) {
            // 添加IS_AUDIT = value条件
            addCriterion("IS_AUDIT =", value, "isAudit");
            return (Criteria) this;
        }

        public Criteria andIsAuditNotEqualTo(Integer value) {
            // 添加IS_AUDIT <> value条件
            addCriterion("IS_AUDIT <>", value, "isAudit");
            return (Criteria) this;
        }

        public Criteria andIsAuditGreaterThan(Integer value) {
            // 添加IS_AUDIT > value条件
            addCriterion("IS_AUDIT >", value, "isAudit");
            return (Criteria) this;
        }

        public Criteria andIsAuditGreaterThanOrEqualTo(Integer value) {
            // 添加IS_AUDIT >= value条件
            addCriterion("IS_AUDIT >=", value, "isAudit");
            return (Criteria) this;
        }

        public Criteria andIsAuditLessThan(Integer value) {
            // 添加IS_AUDIT < value条件
            addCriterion("IS_AUDIT <", value, "isAudit");
            return (Criteria) this;
        }

        public Criteria andIsAuditLessThanOrEqualTo(Integer value) {
            // 添加IS_AUDIT <= value条件
            addCriterion("IS_AUDIT <=", value, "isAudit");
            return (Criteria) this;
        }

        public Criteria andIsAuditIn(List<Integer> values) {
            // 添加IS_AUDIT in values条件
            addCriterion("IS_AUDIT in", values, "isAudit");
            return (Criteria) this;
        }

        public Criteria andIsAuditNotIn(List<Integer> values) {
            // 添加IS_AUDIT not in values条件
            addCriterion("IS_AUDIT not in", values, "isAudit");
            return (Criteria) this;
        }

        public Criteria andIsAuditBetween(Integer value1, Integer value2) {
            // 添加IS_AUDIT between value1 and value2条件
            addCriterion("IS_AUDIT between", value1, value2, "isAudit");
            return (Criteria) this;
        }

        public Criteria andIsAuditNotBetween(Integer value1, Integer value2) {
            // 添加IS_AUDIT not between value1 and value2条件
            addCriterion("IS_AUDIT not between", value1, value2, "isAudit");
            return (Criteria) this;
        }

        public Criteria andCreateDateTimeIsNull() {
            // 添加CREATE_DATE_TIME is null条件
            addCriterion("CREATE_DATE_TIME is null");
            return (Criteria) this;
        }

        public Criteria andCreateDateTimeIsNotNull() {
            // 添加CREATE_DATE_TIME is not null条件
            addCriterion("CREATE_DATE_TIME is not null");
            return (Criteria) this;
        }

        public Criteria andCreateDateTimeEqualTo(Date value) {
            // 添加CREATE_DATE_TIME = value条件
            addCriterion("CREATE_DATE_TIME =", value, "createDateTime");
            return (Criteria) this;
        }

        public Criteria andCreateDateTimeNotEqualTo(Date value) {
            // 添加CREATE_DATE_TIME <> value条件
            addCriterion("CREATE_DATE_TIME <>", value, "createDateTime");
            return (Criteria) this;
        }

        public Criteria andCreateDateTimeGreaterThan(Date value) {
            // 添加CREATE_DATE_TIME > value条件
            addCriterion("CREATE_DATE_TIME >", value, "createDateTime");
            return (Criteria) this;
        }

        public Criteria andCreateDateTimeGreaterThanOrEqualTo(Date value) {
            // 添加CREATE_DATE_TIME >= value条件
            addCriterion("CREATE_DATE_TIME >=", value, "createDateTime");
            return (Criteria) this;
        }

        public Criteria andCreateDateTimeLessThan(Date value) {
            // 添加CREATE_DATE_TIME < value条件
            addCriterion("CREATE_DATE_TIME <", value, "createDateTime");
            return (Criteria) this;
        }

        public Criteria andCreateDateTimeLessThanOrEqualTo(Date value) {
            // 添加CREATE_DATE_TIME <= value条件
            addCriterion("CREATE_DATE_TIME <=", value, "createDateTime");
            return (Criteria) this;
        }

        public Criteria andCreateDateTimeIn(List<Date> values) {
            // 添加CREATE_DATE_TIME in values条件
            addCriterion("CREATE_DATE_TIME in", values, "createDateTime");
            return (Criteria) this;
        }

        public Criteria andCreateDateTimeNotIn(List<Date> values) {
            // 添加CREATE_DATE_TIME not in values条件
            addCriterion("CREATE_DATE_TIME not in", values, "createDateTime");
            return (Criteria) this;
        }

        public Criteria andCreateDateTimeBetween(Date value1, Date value2) {
            // 添加CREATE_DATE_TIME between value1 and value2条件
            addCriterion("CREATE_DATE_TIME between", value1, value2, "createDateTime");
            return (Criteria) this;
        }

        public Criteria andCreateDateTimeNotBetween(Date value1, Date value2) {
            // 添加CREATE_DATE_TIME not between value1 and value2条件
            addCriterion("CREATE_DATE_TIME not between", value1, value2, "createDateTime");
            return (Criteria) this;
        }

        public Criteria andCreateUserCodeIsNull() {
            // 添加CREATE_USER_CODE is null条件
            addCriterion("CREATE_USER_CODE is null");
            return (Criteria) this;
        }

        public Criteria andCreateUserCodeIsNotNull() {
            // 添加CREATE_USER_CODE is not null条件
            addCriterion("CREATE_USER_CODE is not null");
            return (Criteria) this;
        }

        public Criteria andCreateUserCodeEqualTo(String value) {
            // 添加CREATE_USER_CODE = value条件
            addCriterion("CREATE_USER_CODE =", value, "createUserCode");
            return (Criteria) this;
        }

        public Criteria andCreateUserCodeNotEqualTo(String value) {
            // 添加CREATE_USER_CODE <> value条件
            addCriterion("CREATE_USER_CODE <>", value, "createUserCode");
            return (Criteria) this;
        }

        public Criteria andCreateUserCodeGreaterThan(String value) {
            // 添加CREATE_USER_CODE > value条件
            addCriterion("CREATE_USER_CODE >", value, "createUserCode");
            return (Criteria) this;
        }

        public Criteria andCreateUserCodeGreaterThanOrEqualTo(String value) {
            // 添加CREATE_USER_CODE >= value条件
            addCriterion("CREATE_USER_CODE >=", value, "createUserCode");
            return (Criteria) this;
        }

        public Criteria andCreateUserCodeLessThan(String value) {
            // 添加CREATE_USER_CODE < value条件
            addCriterion("CREATE_USER_CODE <", value, "createUserCode");
            return (Criteria) this;
        }

        public Criteria andCreateUserCodeLessThanOrEqualTo(String value) {
            // 添加CREATE_USER_CODE <= value条件
            addCriterion("CREATE_USER_CODE <=", value, "createUserCode");
            return (Criteria) this;
        }

        public Criteria andCreateUserCodeLike(String value) {
            // 添加CREATE_USER_CODE like value条件
            addCriterion("CREATE_USER_CODE like", value, "createUserCode");
            return (Criteria) this;
        }

        public Criteria andCreateUserCodeNotLike(String value) {
            // 添加CREATE_USER_CODE not like value条件
            addCriterion("CREATE_USER_CODE not like", value, "createUserCode");
            return (Criteria) this;
        }

        public Criteria andCreateUserCodeIn(List<String> values) {
            // 添加CREATE_USER_CODE in values条件
            addCriterion("CREATE_USER_CODE in", values, "createUserCode");
            return (Criteria) this;
        }

        public Criteria andCreateUserCodeNotIn(List<String> values) {
            // 添加CREATE_USER_CODE not in values条件
            addCriterion("CREATE_USER_CODE not in", values, "createUserCode");
            return (Criteria) this;
        }

        public Criteria andCreateUserCodeBetween(String value1, String value2) {
            // 添加CREATE_USER_CODE between value1 and value2条件
            addCriterion("CREATE_USER_CODE between", value1, value2, "createUserCode");
            return (Criteria) this;
        }

        public Criteria andCreateUserCodeNotBetween(String value1, String value2) {
            // 添加CREATE_USER_CODE not between value1 and value2条件
            addCriterion("CREATE_USER_CODE not between", value1, value2, "createUserCode");
            return (Criteria) this;
        }

        public Criteria andCaizaiUserIsNull() {
            // 添加CAIZAI_USER is null条件
            addCriterion("CAIZAI_USER is null");
            return (Criteria) this;
        }

        public Criteria andCaizaiUserIsNotNull() {
            // 添加CAIZAI_USER is not null条件
            addCriterion("CAIZAI_USER is not null");
            return (Criteria) this;
        }

        public Criteria andCaizaiUserEqualTo(String value) {
            // 添加CAIZAI_USER = value条件
            addCriterion("CAIZAI_USER =", value, "caizaiUser");
            return (Criteria) this;
        }

        public Criteria andCaizaiUserNotEqualTo(String value) {
            // 添加CAIZAI_USER <> value条件
            addCriterion("CAIZAI_USER <>", value, "caizaiUser");
            return (Criteria) this;
        }

        public Criteria andCaizaiUserGreaterThan(String value) {
            // 添加CAIZAI_USER > value条件
            addCriterion("CAIZAI_USER >", value, "caizaiUser");
            return (Criteria) this;
        }

        public Criteria andCaizaiUserGreaterThanOrEqualTo(String value) {
            // 添加CAIZAI_USER >= value条件
            addCriterion("CAIZAI_USER >=", value, "caizaiUser");
            return (Criteria) this;
        }

        public Criteria andCaizaiUserLessThan(String value) {
            // 添加CAIZAI_USER < value条件
            addCriterion("CAIZAI_USER <", value, "caizaiUser");
            return (Criteria) this;
        }

        public Criteria andCaizaiUserLessThanOrEqualTo(String value) {
            // 添加CAIZAI_USER <= value条件
            addCriterion("CAIZAI_USER <=", value, "caizaiUser");
            return (Criteria) this;
        }

        public Criteria andCaizaiUserLike(String value) {
            // 添加CAIZAI_USER like value条件
            addCriterion("CAIZAI_USER like", value, "caizaiUser");
            return (Criteria) this;
        }

        public Criteria andCaizaiUserNotLike(String value) {
            // 添加CAIZAI_USER not like value条件
            addCriterion("CAIZAI_USER not like", value, "caizaiUser");
            return (Criteria) this;
        }

        public Criteria andCaizaiUserIn(List<String> values) {
            // 添加CAIZAI_USER in values条件
            addCriterion("CAIZAI_USER in", values, "caizaiUser");
            return (Criteria) this;
        }

        public Criteria andCaizaiUserNotIn(List<String> values) {
            // 添加CAIZAI_USER not in values条件
            addCriterion("CAIZAI_USER not in", values, "caizaiUser");
            return (Criteria) this;
        }

        public Criteria andCaizaiUserBetween(String value1, String value2) {
            // 添加CAIZAI_USER between value1 and value2条件
            addCriterion("CAIZAI_USER between", value1, value2, "caizaiUser");
            return (Criteria) this;
        }

        public Criteria andCaizaiUserNotBetween(String value1, String value2) {
            // 添加CAIZAI_USER not between value1 and value2条件
            addCriterion("CAIZAI_USER not between", value1, value2, "caizaiUser");
            return (Criteria) this;
        }

        public Criteria andJianceUserIsNull() {
            // 添加JIANCE_USER is null条件
            addCriterion("JIANCE_USER is null");
            return (Criteria) this;
        }

        public Criteria andJianceUserIsNotNull() {
            // 添加JIANCE_USER is not null条件
            addCriterion("JIANCE_USER is not null");
            return (Criteria) this;
        }

        public Criteria andJianceUserEqualTo(String value) {
            // 添加JIANCE_USER = value条件
            addCriterion("JIANCE_USER =", value, "jianceUser");
            return (Criteria) this;
        }

        public Criteria andJianceUserNotEqualTo(String value) {
            // 添加JIANCE_USER <> value条件
            addCriterion("JIANCE_USER <>", value, "jianceUser");
            return (Criteria) this;
        }

        public Criteria andJianceUserGreaterThan(String value) {
            // 添加JIANCE_USER > value条件
            addCriterion("JIANCE_USER >", value, "jianceUser");
            return (Criteria) this;
        }

        public Criteria andJianceUserGreaterThanOrEqualTo(String value) {
            // 添加JIANCE_USER >= value条件
            addCriterion("JIANCE_USER >=", value, "jianceUser");
            return (Criteria) this;
        }

        // 添加条件：JIANCE_USER < value
        public Criteria andJianceUserLessThan(String value) {
            addCriterion("JIANCE_USER <", value, "jianceUser");
            return (Criteria) this;
        }

        // 添加条件：JIANCE_USER <= value
        public Criteria andJianceUserLessThanOrEqualTo(String value) {
            addCriterion("JIANCE_USER <=", value, "jianceUser");
            return (Criteria) this;
        }

        // 添加条件：JIANCE_USER like value
        public Criteria andJianceUserLike(String value) {
            addCriterion("JIANCE_USER like", value, "jianceUser");
            return (Criteria) this;
        }

        // 添加条件：JIANCE_USER not like value
        public Criteria andJianceUserNotLike(String value) {
            addCriterion("JIANCE_USER not like", value, "jianceUser");
            return (Criteria) this;
        }

        // 添加条件：JIANCE_USER in values
        public Criteria andJianceUserIn(List<String> values) {
            addCriterion("JIANCE_USER in", values, "jianceUser");
            return (Criteria) this;
        }

        // 添加条件：JIANCE_USER not in values
        public Criteria andJianceUserNotIn(List<String> values) {
            addCriterion("JIANCE_USER not in", values, "jianceUser");
            return (Criteria) this;
        }

        // 添加条件：JIANCE_USER between value1 and value2
        public Criteria andJianceUserBetween(String value1, String value2) {
            addCriterion("JIANCE_USER between", value1, value2, "jianceUser");
            return (Criteria) this;
        }

        // 添加条件：JIANCE_USER not between value1 and value2
        public Criteria andJianceUserNotBetween(String value1, String value2) {
            addCriterion("JIANCE_USER not between", value1, value2, "jianceUser");
            return (Criteria) this;
        }

        // 添加条件：NONG_CAN_LV is null
        public Criteria andNongCanLvIsNull() {
            addCriterion("NONG_CAN_LV is null");
            return (Criteria) this;
        }

        // 添加条件：NONG_CAN_LV is not null
        public Criteria andNongCanLvIsNotNull() {
            addCriterion("NONG_CAN_LV is not null");
            return (Criteria) this;
        }

        // 添加条件：NONG_CAN_LV = value
        public Criteria andNongCanLvEqualTo(String value) {
            addCriterion("NONG_CAN_LV =", value, "nongCanLv");
            return (Criteria) this;
        }

        // 添加条件：NONG_CAN_LV <> value
        public Criteria andNongCanLvNotEqualTo(String value) {
            addCriterion("NONG_CAN_LV <>", value, "nongCanLv");
            return (Criteria) this;
        }

        // 添加条件：NONG_CAN_LV > value
        public Criteria andNongCanLvGreaterThan(String value) {
            addCriterion("NONG_CAN_LV >", value, "nongCanLv");
            return (Criteria) this;
        }

        // 添加条件：NONG_CAN_LV >= value
        public Criteria andNongCanLvGreaterThanOrEqualTo(String value) {
            addCriterion("NONG_CAN_LV >=", value, "nongCanLv");
            return (Criteria) this;
        }

        // 添加条件：NONG_CAN_LV < value
        public Criteria andNongCanLvLessThan(String value) {
            addCriterion("NONG_CAN_LV <", value, "nongCanLv");
            return (Criteria) this;
        }

        // 添加条件：NONG_CAN_LV <= value
        public Criteria andNongCanLvLessThanOrEqualTo(String value) {
            addCriterion("NONG_CAN_LV <=", value, "nongCanLv");
            return (Criteria) this;
        }

        // 添加条件：NONG_CAN_LV like value
        public Criteria andNongCanLvLike(String value) {
            addCriterion("NONG_CAN_LV like", value, "nongCanLv");
            return (Criteria) this;
        }

        // 添加条件：NONG_CAN_LV not like value
        public Criteria andNongCanLvNotLike(String value) {
            addCriterion("NONG_CAN_LV not like", value, "nongCanLv");
            return (Criteria) this;
        }

        // 添加条件：NONG_CAN_LV in values
        public Criteria andNongCanLvIn(List<String> values) {
            addCriterion("NONG_CAN_LV in", values, "nongCanLv");
            return (Criteria) this;
        }

        // 添加条件：NONG_CAN_LV not in values
        public Criteria andNongCanLvNotIn(List<String> values) {
            addCriterion("NONG_CAN_LV not in", values, "nongCanLv");
            return (Criteria) this;
        }

        // 添加条件：NONG_CAN_LV between value1 and value2
        public Criteria andNongCanLvBetween(String value1, String value2) {
            addCriterion("NONG_CAN_LV between", value1, value2, "nongCanLv");
            return (Criteria) this;
        }

        // 添加条件：NONG_CAN_LV not between value1 and value2
        public Criteria andNongCanLvNotBetween(String value1, String value2) {
            addCriterion("NONG_CAN_LV not between", value1, value2, "nongCanLv");
            return (Criteria) this;
        }

        // 添加条件：YI_YANG_CHEN_FEN is null
        public Criteria andYiYangChenFenIsNull() {
            addCriterion("YI_YANG_CHEN_FEN is null");
            return (Criteria) this;
        }

        // 添加条件：YI_YANG_CHEN_FEN is not null
        public Criteria andYiYangChenFenIsNotNull() {
            addCriterion("YI_YANG_CHEN_FEN is not null");
            return (Criteria) this;
        }

        // 添加条件：YI_YANG_CHEN_FEN = value
        public Criteria andYiYangChenFenEqualTo(String value) {
            addCriterion("YI_YANG_CHEN_FEN =", value, "yiYangChenFen");
            return (Criteria) this;
        }

        // 添加条件：YI_YANG_CHEN_FEN <> value
        public Criteria andYiYangChenFenNotEqualTo(String value) {
            addCriterion("YI_YANG_CHEN_FEN <>", value, "yiYangChenFen");
            return (Criteria) this;
        }

        // 添加条件：YI_YANG_CHEN_FEN > value
        public Criteria andYiYangChenFenGreaterThan(String value) {
            addCriterion("YI_YANG_CHEN_FEN >", value, "yiYangChenFen");
            return (Criteria) this;
        }

        // 添加条件：YI_YANG_CHEN_FEN >= value
        public Criteria andYiYangChenFenGreaterThanOrEqualTo(String value) {
            addCriterion("YI_YANG_CHEN_FEN >=", value, "yiYangChenFen");
            return (Criteria) this;
        }

        // 添加条件：YI_YANG_CHEN_FEN < value
        public Criteria andYiYangChenFenLessThan(String value) {
            addCriterion("YI_YANG_CHEN_FEN <", value, "yiYangChenFen");
            return (Criteria) this;
        }

        // 添加条件：YI_YANG_CHEN_FEN <= value
        public Criteria andYiYangChenFenLessThanOrEqualTo(String value) {
            addCriterion("YI_YANG_CHEN_FEN <=", value, "yiYangChenFen");
            return (Criteria) this;
        }

        // 添加条件：YI_YANG_CHEN_FEN like value
        public Criteria andYiYangChenFenLike(String value) {
            addCriterion("YI_YANG_CHEN_FEN like", value, "yiYangChenFen");
            return (Criteria) this;
        }

        // 添加条件：YI_YANG_CHEN_FEN not like value
        public Criteria andYiYangChenFenNotLike(String value) {
            addCriterion("YI_YANG_CHEN_FEN not like", value, "yiYangChenFen");
            return (Criteria) this;
        }

        // 添加条件：YI_YANG_CHEN_FEN in values
        public Criteria andYiYangChenFenIn(List<String> values) {
            addCriterion("YI_YANG_CHEN_FEN in", values, "yiYangChenFen");
            return (Criteria) this;
        }

        // 添加条件：YI_YANG_CHEN_FEN not in values
        public Criteria andYiYangChenFenNotIn(List<String> values) {
            addCriterion("YI_YANG_CHEN_FEN not in", values, "yiYangChenFen");
            return (Criteria) this;
        }

        // 添加条件：YI_YANG_CHEN_FEN between value1 and value2
        public Criteria andYiYangChenFenBetween(String value1, String value2) {
            addCriterion("YI_YANG_CHEN_FEN between", value1, value2, "yiYangChenFen");
            return (Criteria) this;
        }

        // 添加条件：YI_YANG_CHEN_FEN not between value1 and value2
        public Criteria andYiYangChenFenNotBetween(String value1, String value2) {
            addCriterion("YI_YANG_CHEN_FEN not between", value1, value2, "yiYangChenFen");
            return (Criteria) this;
        }

        // 添加条件：BAO_ZHI_QI is null
        public Criteria andBaoZhiQiIsNull() {
            addCriterion("BAO_ZHI_QI is null");
            return (Criteria) this;
        }

        // 添加条件：保质量期不为空
        public Criteria andBaoZhiQiIsNotNull() {
            addCriterion("BAO_ZHI_QI is not null");
            return (Criteria) this;
        }

        // 添加条件：保质量期等于指定值
        public Criteria andBaoZhiQiEqualTo(Integer value) {
            addCriterion("BAO_ZHI_QI =", value, "baoZhiQi");
            return (Criteria) this;
        }

        // 添加条件：保质量期不等于指定值
        public Criteria andBaoZhiQiNotEqualTo(Integer value) {
            addCriterion("BAO_ZHI_QI <>", value, "baoZhiQi");
            return (Criteria) this;
        }

        // 添加条件：保质量期大于指定值
        public Criteria andBaoZhiQiGreaterThan(Integer value) {
            addCriterion("BAO_ZHI_QI >", value, "baoZhiQi");
            return (Criteria) this;
        }

        // 添加条件：保质量期大于等于指定值
        public Criteria andBaoZhiQiGreaterThanOrEqualTo(Integer value) {
            addCriterion("BAO_ZHI_QI >=", value, "baoZhiQi");
            return (Criteria) this;
        }

        // 添加条件：保质量期小于指定值
        public Criteria andBaoZhiQiLessThan(Integer value) {
            addCriterion("BAO_ZHI_QI <", value, "baoZhiQi");
            return (Criteria) this;
        }

        // 添加条件：保质量期小于等于指定值
        public Criteria andBaoZhiQiLessThanOrEqualTo(Integer value) {
            addCriterion("BAO_ZHI_QI <=", value, "baoZhiQi");
            return (Criteria) this;
        }

        // 添加条件：保质量期在指定值列表中
        public Criteria andBaoZhiQiIn(List<Integer> values) {
            addCriterion("BAO_ZHI_QI in", values, "baoZhiQi");
            return (Criteria) this;
        }

        // 添加条件：保质量期不在指定值列表中
        public Criteria andBaoZhiQiNotIn(List<Integer> values) {
            addCriterion("BAO_ZHI_QI not in", values, "baoZhiQi");
            return (Criteria) this;
        }

        // 添加条件：保质量期在指定值之间
        public Criteria andBaoZhiQiBetween(Integer value1, Integer value2) {
            addCriterion("BAO_ZHI_QI between", value1, value2, "baoZhiQi");
            return (Criteria) this;
        }

        // 添加条件：保质量期不在指定值之间
        public Criteria andBaoZhiQiNotBetween(Integer value1, Integer value2) {
            addCriterion("BAO_ZHI_QI not between", value1, value2, "baoZhiQi");
            return (Criteria) this;
        }

        // 添加条件：适用人群为空
        public Criteria andShiYiRenQunIsNull() {
            addCriterion("SHI_YI_REN_QUN is null");
            return (Criteria) this;
        }

        // 添加条件：适用人群不为空
        public Criteria andShiYiRenQunIsNotNull() {
            addCriterion("SHI_YI_REN_QUN is not null");
            return (Criteria) this;
        }

        // 添加条件：适用人群等于指定值
        public Criteria andShiYiRenQunEqualTo(String value) {
            addCriterion("SHI_YI_REN_QUN =", value, "shiYiRenQun");
            return (Criteria) this;
        }

        // 添加条件：适用人群不等于指定值
        public Criteria andShiYiRenQunNotEqualTo(String value) {
            addCriterion("SHI_YI_REN_QUN <>", value, "shiYiRenQun");
            return (Criteria) this;
        }

        // 添加条件：适用人群大于指定值
        public Criteria andShiYiRenQunGreaterThan(String value) {
            addCriterion("SHI_YI_REN_QUN >", value, "shiYiRenQun");
            return (Criteria) this;
        }

        // 添加条件：适用人群大于等于指定值
        public Criteria andShiYiRenQunGreaterThanOrEqualTo(String value) {
            addCriterion("SHI_YI_REN_QUN >=", value, "shiYiRenQun");
            return (Criteria) this;
        }

        // 添加条件：适用人群小于指定值
        public Criteria andShiYiRenQunLessThan(String value) {
            addCriterion("SHI_YI_REN_QUN <", value, "shiYiRenQun");
            return (Criteria) this;
        }

        // 添加条件：适用人群小于等于指定值
        public Criteria andShiYiRenQunLessThanOrEqualTo(String value) {
            addCriterion("SHI_YI_REN_QUN <=", value, "shiYiRenQun");
            return (Criteria) this;
        }

        // 添加条件：适用人群包含指定值
        public Criteria andShiYiRenQunLike(String value) {
            addCriterion("SHI_YI_REN_QUN like", value, "shiYiRenQun");
            return (Criteria) this;
        }

        // 添加条件：适用人群不包含指定值
        public Criteria andShiYiRenQunNotLike(String value) {
            addCriterion("SHI_YI_REN_QUN not like", value, "shiYiRenQun");
            return (Criteria) this;
        }

        // 添加条件：适用人群在指定值列表中
        public Criteria andShiYiRenQunIn(List<String> values) {
            addCriterion("SHI_YI_REN_QUN in", values, "shiYiRenQun");
            return (Criteria) this;
        }

        // 添加条件：适用人群不在指定值列表中
        public Criteria andShiYiRenQunNotIn(List<String> values) {
            addCriterion("SHI_YI_REN_QUN not in", values, "shiYiRenQun");
            return (Criteria) this;
        }

        // 添加条件：适用人群在指定值之间
        public Criteria andShiYiRenQunBetween(String value1, String value2) {
            addCriterion("SHI_YI_REN_QUN between", value1, value2, "shiYiRenQun");
            return (Criteria) this;
        }

        // 添加条件：适用人群不在指定值之间
        public Criteria andShiYiRenQunNotBetween(String value1, String value2) {
            addCriterion("SHI_YI_REN_QUN not between", value1, value2, "shiYiRenQun");
            return (Criteria) this;
        }

        // 添加条件：限时抢购为空
        public Criteria andXianShiQiangGouIsNull() {
            addCriterion("XIAN_SHI_QIANG_GOU is null");
            return (Criteria) this;
        }

        // 添加条件：限时抢购不为空
        public Criteria andXianShiQiangGouIsNotNull() {
            addCriterion("XIAN_SHI_QIANG_GOU is not null");
            return (Criteria) this;
        }

        // 添加条件：限时抢购等于指定值
        public Criteria andXianShiQiangGouEqualTo(Integer value) {
            addCriterion("XIAN_SHI_QIANG_GOU =", value, "xianShiQiangGou");
            return (Criteria) this;
        }

        // 添加条件：限时抢购不等于指定值
        public Criteria andXianShiQiangGouNotEqualTo(Integer value) {
            addCriterion("XIAN_SHI_QIANG_GOU <>", value, "xianShiQiangGou");
            return (Criteria) this;
        }

        // 添加条件：限时抢购大于指定值
        public Criteria andXianShiQiangGouGreaterThan(Integer value) {
            addCriterion("XIAN_SHI_QIANG_GOU >", value, "xianShiQiangGou");
            return (Criteria) this;
        }

        // 添加条件：限时抢购大于等于指定值
        public Criteria andXianShiQiangGouGreaterThanOrEqualTo(Integer value) {
            addCriterion("XIAN_SHI_QIANG_GOU >=", value, "xianShiQiangGou");
            return (Criteria) this;
        }

        // 添加条件：限时抢购小于指定值
        public Criteria andXianShiQiangGouLessThan(Integer value) {
            addCriterion("XIAN_SHI_QIANG_GOU <", value, "xianShiQiangGou");
            return (Criteria) this;
        }

        // 添加条件：限时抢购小于等于指定值
        public Criteria andXianShiQiangGouLessThanOrEqualTo(Integer value) {
            addCriterion("XIAN_SHI_QIANG_GOU <=", value, "xianShiQiangGou");
            return (Criteria) this;
        }

        // 添加条件：限时抢购在指定值列表中
        public Criteria andXianShiQiangGouIn(List<Integer> values) {
            addCriterion("XIAN_SHI_QIANG_GOU in", values, "xianShiQiangGou");
            return (Criteria) this;
        }

        // 添加条件：限时抢购不在指定值列表中
        public Criteria andXianShiQiangGouNotIn(List<Integer> values) {
            addCriterion("XIAN_SHI_QIANG_GOU not in", values, "xianShiQiangGou");
            return (Criteria) this;
        }

        // 添加条件：限时抢购在指定值之间
        public Criteria andXianShiQiangGouBetween(Integer value1, Integer value2) {
            addCriterion("XIAN_SHI_QIANG_GOU between", value1, value2, "xianShiQiangGou");
            return (Criteria) this;
        }

        // 添加条件：限时抢购不在指定值之间
        public Criteria andXianShiQiangGouNotBetween(Integer value1, Integer value2) {
            addCriterion("XIAN_SHI_QIANG_GOU not between", value1, value2, "xianShiQiangGou");
            return (Criteria) this;
        }

        // 添加条件：新品常鲜为空
        public Criteria andXinPinChangXianIsNull() {
            addCriterion("XIN_PIN_CHANG_XIAN is null");
            return (Criteria) this;
        }

        // 添加条件：新品常鲜不为空
        public Criteria andXinPinChangXianIsNotNull() {
            addCriterion("XIN_PIN_CHANG_XIAN is not null");
            return (Criteria) this;
        }

        // 添加条件：新品常鲜等于指定值
        public Criteria andXinPinChangXianEqualTo(Integer value) {
            addCriterion("XIN_PIN_CHANG_XIAN =", value, "xinPinChangXian");
            return (Criteria) this;
        }

        // 添加条件：新品常鲜不等于指定值
        public Criteria andXinPinChangXianNotEqualTo(Integer value) {
            addCriterion("XIN_PIN_CHANG_XIAN <>", value, "xinPinChangXian");
            return (Criteria) this;
        }

        // 添加条件：新品常鲜大于指定值
        public Criteria andXinPinChangXianGreaterThan(Integer value) {
            addCriterion("XIN_PIN_CHANG_XIAN >", value, "xinPinChangXian");
            return (Criteria) this;
        }

        // 添加条件：新品常鲜大于等于指定值
        public Criteria andXinPinChangXianGreaterThanOrEqualTo(Integer value) {
            addCriterion("XIN_PIN_CHANG_XIAN >=", value, "xinPinChangXian");
            return (Criteria) this;
        }

        // 添加条件：新品常鲜小于指定值
        public Criteria andXinPinChangXianLessThan(Integer value) {
            addCriterion("XIN_PIN_CHANG_XIAN <", value, "xinPinChangXian");
            return (Criteria) this;
        }

        // 添加条件：新品常鲜小于等于指定值
        public Criteria andXinPinChangXianLessThanOrEqualTo(Integer value) {
            addCriterion("XIN_PIN_CHANG_XIAN <=", value, "xinPinChangXian");
            return (Criteria) this;
        }

        // 添加条件：新品常鲜在指定值列表中
        public Criteria andXinPinChangXianIn(List<Integer> values) {
            addCriterion("XIN_PIN_CHANG_XIAN in", values, "xinPinChangXian");
            return (Criteria) this;
        }

        public Criteria andXinPinChangXianNotIn(List<Integer> values) {
            // 添加条件：XIN_PIN_CHANG_XIAN not in values
            addCriterion("XIN_PIN_CHANG_XIAN not in", values, "xinPinChangXian");
            return (Criteria) this;
        }

        public Criteria andXinPinChangXianBetween(Integer value1, Integer value2) {
            // 添加条件：XIN_PIN_CHANG_XIAN between value1 and value2
            addCriterion("XIN_PIN_CHANG_XIAN between", value1, value2, "xinPinChangXian");
            return (Criteria) this;
        }

        public Criteria andXinPinChangXianNotBetween(Integer value1, Integer value2) {
            // 添加条件：XIN_PIN_CHANG_XIAN not between value1 and value2
            addCriterion("XIN_PIN_CHANG_XIAN not between", value1, value2, "xinPinChangXian");
            return (Criteria) this;
        }

        public Criteria andReMaiTuiJianIsNull() {
            // 添加条件：RE_MAI_TUI_JIAN is null
            addCriterion("RE_MAI_TUI_JIAN is null");
            return (Criteria) this;
        }

        public Criteria andReMaiTuiJianIsNotNull() {
            // 添加条件：RE_MAI_TUI_JIAN is not null
            addCriterion("RE_MAI_TUI_JIAN is not null");
            return (Criteria) this;
        }

        public Criteria andReMaiTuiJianEqualTo(Integer value) {
            // 添加条件：RE_MAI_TUI_JIAN = value
            addCriterion("RE_MAI_TUI_JIAN =", value, "reMaiTuiJian");
            return (Criteria) this;
        }

        public Criteria andReMaiTuiJianNotEqualTo(Integer value) {
            // 添加条件：RE_MAI_TUI_JIAN <> value
            addCriterion("RE_MAI_TUI_JIAN <>", value, "reMaiTuiJian");
            return (Criteria) this;
        }

        public Criteria andReMaiTuiJianGreaterThan(Integer value) {
            // 添加条件：RE_MAI_TUI_JIAN > value
            addCriterion("RE_MAI_TUI_JIAN >", value, "reMaiTuiJian");
            return (Criteria) this;
        }

        public Criteria andReMaiTuiJianGreaterThanOrEqualTo(Integer value) {
            // 添加条件：RE_MAI_TUI_JIAN >= value
            addCriterion("RE_MAI_TUI_JIAN >=", value, "reMaiTuiJian");
            return (Criteria) this;
        }

        public Criteria andReMaiTuiJianLessThan(Integer value) {
            // 添加条件：RE_MAI_TUI_JIAN < value
            addCriterion("RE_MAI_TUI_JIAN <", value, "reMaiTuiJian");
            return (Criteria) this;
        }

        public Criteria andReMaiTuiJianLessThanOrEqualTo(Integer value) {
            // 添加条件：RE_MAI_TUI_JIAN <= value
            addCriterion("RE_MAI_TUI_JIAN <=", value, "reMaiTuiJian");
            return (Criteria) this;
        }

        public Criteria andReMaiTuiJianIn(List<Integer> values) {
            // 添加条件：RE_MAI_TUI_JIAN in values
            addCriterion("RE_MAI_TUI_JIAN in", values, "reMaiTuiJian");
            return (Criteria) this;
        }

        public Criteria andReMaiTuiJianNotIn(List<Integer> values) {
            // 添加条件：RE_MAI_TUI_JIAN not in values
            addCriterion("RE_MAI_TUI_JIAN not in", values, "reMaiTuiJian");
            return (Criteria) this;
        }

        public Criteria andReMaiTuiJianBetween(Integer value1, Integer value2) {
            // 添加条件：RE_MAI_TUI_JIAN between value1 and value2
            addCriterion("RE_MAI_TUI_JIAN between", value1, value2, "reMaiTuiJian");
            return (Criteria) this;
        }

        public Criteria andReMaiTuiJianNotBetween(Integer value1, Integer value2) {
            // 添加条件：RE_MAI_TUI_JIAN not between value1 and value2
            addCriterion("RE_MAI_TUI_JIAN not between", value1, value2, "reMaiTuiJian");
            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);
        }
    }
}