package com.xmomen.module.plan.entity;

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

/**
 * TbTablePlanExample类用于生成针对TbTablePlan实体的查询条件。
 * 它继承自BaseMybatisExample，提供了构建复杂查询条件的能力，
 * 可以组合多个查询条件，并支持排序、去重等功能，用于与数据库交互时筛选符合条件的数据。
 */
public class TbTablePlanExample extends BaseMybatisExample {

    // 用于存储排序子句，例如 "column_name ASC" 或 "column_name DESC"
    protected String orderByClause;

    // 用于标记是否需要去重查询结果，true表示去重，false表示不去重
    protected boolean distinct;

    // 存储多个查询条件，每个Criteria对象代表一个查询条件，
    // 多个Criteria之间是逻辑或（OR）的关系
    protected List<Criteria> oredCriteria;

    /**
     * 构造函数，初始化oredCriteria列表，用于存储查询条件。
     */
    public TbTablePlanExample() {
        oredCriteria = new ArrayList<Criteria>();
    }

    /**
     * 设置排序子句。
     * @param orderByClause 排序子句，例如 "column_name ASC" 或 "column_name DESC"
     */
    public void setOrderByClause(String orderByClause) {
        this.orderByClause = orderByClause;
    }

    /**
     * 获取排序子句。
     * @return 排序子句
     */
    public String getOrderByClause() {
        return orderByClause;
    }

    /**
     * 设置是否去重查询结果。
     * @param distinct true表示去重，false表示不去重
     */
    public void setDistinct(boolean distinct) {
        this.distinct = distinct;
    }

    /**
     * 判断是否需要去重查询结果。
     * @return true表示去重，false表示不去重
     */
    public boolean isDistinct() {
        return distinct;
    }

    /**
     * 获取存储查询条件的列表。
     * @return 包含多个Criteria对象的列表，每个Criteria对象代表一个查询条件
     */
    public List<Criteria> getOredCriteria() {
        return oredCriteria;
    }

    /**
     * 将一个查询条件添加到oredCriteria列表中，多个条件之间是逻辑或（OR）的关系。
     * @param criteria 要添加的查询条件对象
     */
    public void or(Criteria criteria) {
        oredCriteria.add(criteria);
    }

    /**
     * 创建一个新的查询条件对象，并将其添加到oredCriteria列表中，
     * 然后返回这个新的查询条件对象，方便链式调用设置具体条件。
     * @return 新创建的查询条件对象
     */
    public Criteria or() {
        Criteria criteria = createCriteriaInternal();
        oredCriteria.add(criteria);
        return criteria;
    }

    /**
     * 创建一个新的查询条件对象，如果oredCriteria列表为空，则将其添加到列表中，
     * 然后返回这个新的查询条件对象，方便链式调用设置具体条件。
     * @return 新创建的查询条件对象
     */
    public Criteria createCriteria() {
        Criteria criteria = createCriteriaInternal();
        if (oredCriteria.size() == 0) {
            oredCriteria.add(criteria);
        }
        return criteria;
    }

    /**
     * 内部方法，用于创建一个新的查询条件对象。
     * @return 新创建的查询条件对象
     */
    protected Criteria createCriteriaInternal() {
        Criteria criteria = new Criteria();
        return criteria;
    }

    /**
     * 清空所有查询条件、排序子句和去重标记，重置TbTablePlanExample对象的状态。
     */
    public void clear() {
        oredCriteria.clear();
        orderByClause = null;
        distinct = false;
    }

    /**
     * 内部抽象静态类，用于生成具体的查询条件。
     * 它包含了一系列方法，用于构建各种类型的查询条件，如等于、不等于、大于等。
     */
    protected abstract static class GeneratedCriteria {

        // 存储具体的查询条件，每个Criterion对象代表一个条件
        protected List<Criterion> criteria;

        /**
         * 构造函数，初始化criteria列表，用于存储查询条件。
         */
        protected GeneratedCriteria() {
            super();
            criteria = new ArrayList<Criterion>();
        }

        /**
         * 判断当前生成的查询条件是否有效，即是否至少有一个条件。
         * @return true表示至少有一个条件，false表示没有条件
         */
        public boolean isValid() {
            return criteria.size() > 0;
        }

        /**
         * 获取所有的查询条件列表。
         * @return 包含多个Criterion对象的列表，每个Criterion对象代表一个条件
         */
        public List<Criterion> getAllCriteria() {
            return criteria;
        }

        /**
         * 获取查询条件列表。
         * @return 包含多个Criterion对象的列表，每个Criterion对象代表一个条件
         */
        public List<Criterion> getCriteria() {
            return criteria;
        }

        /**
         * 添加一个不带值的查询条件，例如 "column_name is null"。
         * @param condition 查询条件字符串
         */
        protected void addCriterion(String condition) {
            if (condition == null) {
                throw new RuntimeException("Value for condition cannot be null");
            }
            criteria.add(new Criterion(condition));
        }

        /**
         * 添加一个带单个值的查询条件，例如 "column_name = value"。
         * @param condition 查询条件字符串
         * @param value 查询条件对应的值
         * @param property 对应的属性名（可能用于日志或调试）
         */
        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));
        }

        /**
         * 添加一个带两个值的查询条件，例如 "column_name between value1 and value2"。
         * @param condition 查询条件字符串
         * @param value1 第一个值
         * @param value2 第二个值
         * @param property 对应的属性名（可能用于日志或调试）
         */
        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));
        }

        /**
         * 针对日期类型，添加一个带单个日期值的查询条件，
         * 会将Java的Date类型转换为JDBC的Date类型。
         * @param condition 查询条件字符串
         * @param value 日期值
         * @param property 对应的属性名（可能用于日志或调试）
         */
        protected void addCriterionForJDBCDate(String condition, Date value, String property) {
            if (value == null) {
                throw new RuntimeException("Value for " + property + " cannot be null");
            }
            addCriterion(condition, new java.sql.Date(value.getTime()), property);
        }

        /**
         * 针对日期类型，添加一个带日期值列表的查询条件，
         * 会将Java的Date类型列表转换为JDBC的Date类型列表。
         * @param condition 查询条件字符串
         * @param values 日期值列表
         * @param property 对应的属性名（可能用于日志或调试）
         */
        protected void addCriterionForJDBCDate(String condition, List<Date> values, String property) {
            if (values == null || values.size() == 0) {
                throw new RuntimeException("Value list for " + property + " cannot be null or empty");
            }
            List<java.sql.Date> dateList = new ArrayList<java.sql.Date>();
            Iterator<Date> iter = values.iterator();
            while (iter.hasNext()) {
                dateList.add(new java.sql.Date(iter.next().getTime()));
            }
            addCriterion(condition, dateList, property);
        }

        /**
         * 针对日期类型，添加一个带两个日期值的查询条件，
         * 会将Java的Date类型转换为JDBC的Date类型。
         * @param condition 查询条件字符串
         * @param value1 第一个日期值
         * @param value2 第二个日期值
         * @param property 对应的属性名（可能用于日志或调试）
         */
        protected void addCriterionForJDBCDate(String condition, Date value1, Date value2, String property) {
            if (value1 == null || value2 == null) {
                throw new RuntimeException("Between values for " + property + " cannot be null");
            }
            addCriterion(condition, new java.sql.Date(value1.getTime()), new java.sql.Date(value2.getTime()), property);
        }

        // 以下是针对TbTablePlan实体的各个字段生成的具体查询条件方法，例如针对id字段的查询条件

        /**
         * 添加一个查询条件："ID is null"。
         * @return 当前的查询条件对象，方便链式调用
         */
        public Criteria andIdIsNull() {
            addCriterion("ID is null");
            return (Criteria) this;
        }

        // 省略其他字段的查询条件方法注释，它们的作用类似，都是生成针对相应字段的查询条件

        // ......

    }

    /**
     * 具体的查询条件类，继承自GeneratedCriteria，用于构建具体的查询条件。
     */
    public static class Criteria extends GeneratedCriteria {

        /**
         * 构造函数，调用父类的构造函数初始化查询条件列表。
         */
        protected Criteria() {
            super();
        }

        public void andIdEqualTo(Integer id) {
        }
    }

    /**
     * 表示单个查询条件的类，包含条件字符串、值、第二个值等信息。
     */
    public static class Criterion {

        // 查询条件字符串，例如 "column_name = value" 中的 "column_name ="
        private String condition;

        // 条件对应的值，例如 "column_name = value" 中的 "value"
        private Object value;

        // 条件对应第二个值（用于between等条件），例如 "column_name between value1 and value2" 中的 "value2"
        private Object secondValue;

        // 标记是否没有值，例如 "column_name is null" 这种情况
        private boolean noValue;

        // 标记是否是单个值的条件，例如 "column_name = value"
        private boolean singleValue;

        // 标记是否是两个值的条件，例如 "column_name between value1 and value2"
        private boolean betweenValue;

        // 标记是否是列表值的条件，例如 "column_name in (value1, value2,...)"
        private boolean listValue;

        // 类型处理器，可能用于处理特殊类型的值转换
        private String typeHandler;

        // 以下是获取各个属性值的方法

        /**
         * 获取查询条件字符串。
         * @return 查询条件字符串
         */
        public String getCondition() {
            return condition;
        }

        // 省略其他获取属性值的方法注释，它们的作用是获取相应的属性值

        // ......

        // 以下是不同参数的构造函数，用于创建Criterion对象

        /**
         * 构造函数，创建一个不带值的查询条件对象。
         * @param condition 查询条件字符串
         */
        protected Criterion(String condition) {
            super();
            this.condition = condition;
            this.typeHandler = null;
            this.noValue = true;
        }

        // 省略其他构造函数注释，它们的作用是根据不同的参数创建Criterion对象

        // ......
    }
}