package com.xmomen.module.pick.entity;

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

/**
 * TbPickExample 类用于构建查询 TbPick 表的条件。
 * 它继承自 BaseMybatisExample，提供了一系列方法来动态生成 SQL 查询的 WHERE 子句。
 * 通过该类可以方便地设置排序规则、去重标志以及添加各种查询条件。
 */
public class TbPickExample extends BaseMybatisExample {
    // 用于指定查询结果的排序规则，例如 "ID ASC"
    protected String orderByClause;
    // 用于指定查询结果是否去重
    protected boolean distinct;
    // 存储多个查询条件集合，每个 Criteria 代表一组 AND 条件，多个 Criteria 之间是 OR 关系
    protected List<Criteria> oredCriteria;


    public TbPickExample() {
        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;
    }


    protected abstract static class GeneratedCriteria {
        // 存储具体的查询条件
        protected List<Criterion> 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));
        }

        // 以下是针对 TbPick 表各个字段的查询条件生成方法


        public Criteria andIdIsNull() {
            addCriterion("ID is null");
            return (Criteria) this;
        }


        public Criteria andIdIsNotNull() {
            addCriterion("ID is not null");
            return (Criteria) this;
        }


        public Criteria andIdEqualTo(Integer value) {
            addCriterion("ID =", value, "id");
            return (Criteria) this;
        }

        // 其他针对 ID 字段的条件生成方法，如不等于、大于、小于等


        public Criteria andCouponNoIsNull() {
            addCriterion("COUPON_NO is null");
            return (Criteria) this;
        }

        // 其他针对 COUPON_NO 字段的条件生成方法

        // 以此类推，针对其他字段（如 PICK_WEIGHT、PICK_PAY_TYPE 等）的条件生成方法

    }


    public static class Criteria extends GeneratedCriteria {


        protected Criteria() {
            super();
        }
    }


    public static class Criterion {
        // 查询条件的字符串表示，例如 "ID = "
        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;
            }
        }


        public 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);
        }
    }
}