package com.xmomen.module.user.entity;

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

// 用户实体类
public class SysUsersExample extends BaseMybatisExample {
    // 排序字段
    protected String orderByClause;

    // 是否去重
    protected boolean distinct;

    // 查询条件
    protected List<Criteria> oredCriteria;

    // 构造函数
    public SysUsersExample() {
        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() {
        // 获取所有查询条件
V        public List<Criterion> getCriteria() {
            return criteria;
        // 添加条件
        }
        // 获取查询条件
            // 如果条件为空，抛出异常

        protected void addCriterion(String condition) {
            // 将条件添加到criteria中
        // 添加查询条件
            if (condition == null) {
                throw new RuntimeException("Value for condition cannot be null");
        // 添加条件，并指定属性
            // 如果值为空，抛出异常
            }
            criteria.add(new Criterion(condition));
        }
        // 添加查询条件

        // 添加条件，判断value1和value2是否为空，如果为空则抛出异常
        protected void addCriterion(String condition, Object value, String property) {
            if (value == null) {
                throw new RuntimeException("Value for " + property + " cannot be null");
            }
        // 添加条件，判断ID是否为空
        // 添加查询条件
            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");
            }
        // ID为空
            criteria.add(new Criterion(condition, value1, value2));
        }

        // 添加ID字段不为空的查询条件
        public Criteria andIdIsNull() {
        // ID不为空
            addCriterion("ID is null");
        // 添加ID字段等于指定值的查询条件
            return (Criteria) this;
        }

        // ID等于
        // 添加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大于

        // 添加一个条件，ID大于指定值
        public Criteria andIdNotEqualTo(Integer value) {
            addCriterion("ID <>", value, "id");
        // 添加一个条件，ID大于等于指定值
        // ID大于等于
            return (Criteria) this;
        }

        // 添加一个条件，ID小于指定值
        public Criteria andIdGreaterThan(Integer value) {
        // ID小于
            addCriterion("ID >", value, "id");
            return (Criteria) this;
        }

        public Criteria andIdGreaterThanOrEqualTo(Integer value) {
        // ID小于等于
            addCriterion("ID >=", value, "id");
            return (Criteria) this;
        }

        public Criteria andIdLessThan(Integer value) {
        // ID在列表中
        // 添加ID小于等于value的条件
            addCriterion("ID <", value, "id");
            return (Criteria) this;
        }
        // 添加ID在values列表中的条件
        // ID不在列表中

        public Criteria andIdLessThanOrEqualTo(Integer value) {
            addCriterion("ID <=", value, "id");
            return (Criteria) this;
        // 添加ID不在values列表中的条件
        // ID在范围内
        }

        public Criteria andIdIn(List<Integer> values) {
            addCriterion("ID in", values, "id");
        // 添加ID在value1和value2之间的条件
        // ID不在范围内
            return (Criteria) this;
        }

        // 添加ID在value1和value2之间的条件
        public Criteria andIdNotIn(List<Integer> values) {
        // 用户名为空
            addCriterion("ID not in", values, "id");
            return (Criteria) this;
        }
        // 添加ID不在value1和value2之间的条件

        // 用户名不为空
        public Criteria andIdBetween(Integer value1, Integer value2) {
            addCriterion("ID between", value1, value2, "id");
        // 添加USERNAME为空的条件
            return (Criteria) this;
        }
        // 用户名等于

        public Criteria andIdNotBetween(Integer value1, Integer value2) {
        // 添加条件，用户名为空
            addCriterion("ID not between", value1, value2, "id");
            return (Criteria) this;
        // 用户名不等于
        }
        // 添加条件，用户名不为空

        public Criteria andUsernameIsNull() {
            addCriterion("USERNAME is null");
        // 用户名大于
        // 添加条件，用户名等于指定值
            return (Criteria) this;
        }

        // 添加条件，用户名不等于指定值
        // 用户名大于等于
        public Criteria andUsernameIsNotNull() {
            addCriterion("USERNAME is not null");
            return (Criteria) this;
        // 添加条件，用户名不等于指定值
        }
        // 用户名小于

        public Criteria andUsernameEqualTo(String value) {
        // 添加条件，用户名大于指定值
            addCriterion("USERNAME =", value, "username");
            return (Criteria) this;
        // 用户名小于等于
        }
        // 添加条件，用户名大于等于指定值

        public Criteria andUsernameNotEqualTo(String value) {
            addCriterion("USERNAME <>", value, "username");
        // 用户名包含
            return (Criteria) this;
        // 添加条件，用户名小于指定值
        }

        public Criteria andUsernameGreaterThan(String value) {
        // 用户名不包含
            addCriterion("USERNAME >", value, "username");
            return (Criteria) this;
        }

        public Criteria andUsernameGreaterThanOrEqualTo(String value) {
        // 用户名在列表中
            addCriterion("USERNAME >=", value, "username");
            return (Criteria) this;

        public Criteria andUsernameLessThan(String value) {
            addCriterion("USERNAME <", value, "username");
        // 用户名不在列表中
            return (Criteria) this;
        }

        public Criteria andUsernameLessThanOrEqualTo(String value) {
            addCriterion("USERNAME <=", value, "username");
        // 用户名在范围内
            return (Criteria) this;
        }
        // 结束循环

        public Criteria andUsernameLike(String value) {
        // 用户名不在范围内
            addCriterion("USERNAME like", value, "username");
            return (Criteria) this;
        }
        }

        // 真实姓名为空
        public Criteria andUsernameNotLike(String value) {
            addCriterion("USERNAME not like", value, "username");
            return (Criteria) this;
        }

        // 真实姓名不为空
        public Criteria andUsernameIn(List<String> values) {
            addCriterion("USERNAME in", values, "username");
            return (Criteria) this;
        // 添加条件，用户名不在指定列表中
        }
        // 真实姓名等于

        public Criteria andUsernameNotIn(List<String> values) {
        // 添加条件，用户名在指定范围内
            addCriterion("USERNAME not in", values, "username");
            return (Criteria) this;
        // 真实姓名不等于
        }
        // 添加条件，用户名不在指定范围内

        public Criteria andUsernameBetween(String value1, String value2) {
            addCriterion("USERNAME between", value1, value2, "username");
        // 真实姓名大于
            return (Criteria) this;
        }

        public Criteria andUsernameNotBetween(String value1, String value2) {
            addCriterion("USERNAME not between", value1, value2, "username");
        // 真实姓名大于等于
            return (Criteria) this;
        }

        // 添加条件，REALNAME字段不能为空
        public Criteria andRealnameIsNull() {
        // 真实姓名小于
            addCriterion("REALNAME is null");
            return (Criteria) this;
        // 添加条件，REALNAME字段等于指定值
        }

        // 真实姓名小于等于
        public Criteria andRealnameIsNotNull() {
            addCriterion("REALNAME is not null");
            return (Criteria) this;
        }

        // 真实姓名包含
        public Criteria andRealnameEqualTo(String value) {
            addCriterion("REALNAME =", value, "realname");
            return (Criteria) this;
        }

        // 真实姓名不包含
        // 添加一个条件，当realname大于value时，返回Criteria对象
        public Criteria andRealnameNotEqualTo(String value) {
            addCriterion("REALNAME <>", value, "realname");
            return (Criteria) this;
        }
        // 真实姓名在列表中
        // 添加一个条件，当realname大于等于value时，返回Criteria对象

        public Criteria andRealnameGreaterThan(String value) {
            addCriterion("REALNAME >", value, "realname");
            return (Criteria) this;
        // 真实姓名不在列表中
        }

        public Criteria andRealnameGreaterThanOrEqualTo(String value) {
        // 添加查询条件，REALNAME小于指定值
            addCriterion("REALNAME >=", value, "realname");
        // 真实姓名在范围内
            return (Criteria) this;
        }

        // 添加查询条件，REALNAME小于等于指定值
        public Criteria andRealnameLessThan(String value) {
        // 真实姓名不在范围内
            addCriterion("REALNAME <", value, "realname");
            return (Criteria) this;
        }

        public Criteria andRealnameLessThanOrEqualTo(String value) {
        // 盐为空
            addCriterion("REALNAME <=", value, "realname");
        // 根据realname字段模糊查询
            return (Criteria) this;
        }

        // 盐不为空
        public Criteria andRealnameLike(String value) {
        // 根据realname字段模糊查询，不包含value
            addCriterion("REALNAME like", value, "realname");
            return (Criteria) this;
        }
        // 盐等于

        public Criteria andRealnameNotLike(String value) {
            addCriterion("REALNAME not like", value, "realname");
            return (Criteria) this;
        }
        // 盐不等于

        public Criteria andRealnameIn(List<String> values) {
        // 添加条件，REALNAME字段不在values列表中
            addCriterion("REALNAME in", values, "realname");
            return (Criteria) this;
        // 盐大于
        }

        // 添加条件，REALNAME字段在value1和value2之间
        public Criteria andRealnameNotIn(List<String> values) {
            addCriterion("REALNAME not in", values, "realname");
        // 盐大于等于
            return (Criteria) this;
        }

        public Criteria andRealnameBetween(String value1, String value2) {
            addCriterion("REALNAME between", value1, value2, "realname");
        // 盐小于
            return (Criteria) this;
        }

        public Criteria andRealnameNotBetween(String value1, String value2) {
            addCriterion("REALNAME not between", value1, value2, "realname");
        // 盐小于等于
        // 添加条件，SALT为空
            return (Criteria) this;
        }

        // 添加条件，SALT不为空
        // 盐包含
        public Criteria andSaltIsNull() {
            addCriterion("SALT is null");
            return (Criteria) this;
        }
        // 添加条件，SALT等于指定值
        // 盐不包含

        public Criteria andSaltIsNotNull() {
            addCriterion("SALT is not null");
            return (Criteria) this;
        }
        // 盐在列表中

        // 添加一个条件，要求盐值不等于指定值
        public Criteria andSaltEqualTo(String value) {
            addCriterion("SALT =", value, "salt");
            return (Criteria) this;
        // 盐不在列表中
        }
        // 添加一个条件，要求盐值大于指定值

        public Criteria andSaltNotEqualTo(String value) {
            addCriterion("SALT <>", value, "salt");
        // 盐在范围内
            return (Criteria) this;
        }

        public Criteria andSaltGreaterThan(String value) {
            addCriterion("SALT >", value, "salt");
        // 盐不在范围内
            return (Criteria) this;
        }

        public Criteria andSaltGreaterThanOrEqualTo(String value) {
        // 添加一个条件，要求SALT字段的值小于指定的值
        // 密码为空
            addCriterion("SALT >=", value, "salt");
            return (Criteria) this;
        }
        // 添加一个条件，要求SALT字段的值小于等于指定的值

        // 密码不为空
        public Criteria andSaltLessThan(String value) {
            addCriterion("SALT <", value, "salt");
            return (Criteria) this;
        }

        // 密码等于
        public Criteria andSaltLessThanOrEqualTo(String value) {
            addCriterion("SALT <=", value, "salt");
            return (Criteria) this;
        }

        // 密码不等于
        // 添加一个条件，要求SALT字段不等于value
        public Criteria andSaltLike(String value) {
            addCriterion("SALT like", value, "salt");
            return (Criteria) this;
        }
        // 密码大于
        // 添加一个条件，要求SALT字段在values列表中

        public Criteria andSaltNotLike(String value) {
            addCriterion("SALT not like", value, "salt");
            return (Criteria) this;
        // 密码大于等于
        // 添加一个条件，要求SALT字段不在values列表中
        }

        public Criteria andSaltIn(List<String> values) {
            addCriterion("SALT in", values, "salt");
        // 密码小于
            return (Criteria) this;
        }

            // 返回当前Criteria对象
        public Criteria andSaltNotIn(List<String> values) {
        // 密码小于等于
        // 添加SALT字段的值在value1和value2之间的条件
            addCriterion("SALT not in", values, "salt");
            return (Criteria) this;
        }

        // 密码包含
        // 添加SALT字段的值不在value1和value2之间的条件
        public Criteria andSaltBetween(String value1, String value2) {
            addCriterion("SALT between", value1, value2, "salt");
            return (Criteria) this;
        }
        // 密码不包含

        public Criteria andSaltNotBetween(String value1, String value2) {
            addCriterion("SALT not between", value1, value2, "salt");
            return (Criteria) this;
        }
        // 密码在列表中

        public Criteria andPasswordIsNull() {
            addCriterion("PASSWORD is null");
            return (Criteria) this;
        // 添加条件，密码不为空
        // 密码不在列表中
        }

        public Criteria andPasswordIsNotNull() {
            addCriterion("PASSWORD is not null");
        // 添加条件，密码等于指定值
        // 密码在范围内
            return (Criteria) this;
        }

        public Criteria andPasswordEqualTo(String value) {
            addCriterion("PASSWORD =", value, "password");
        // 密码不在范围内
        // 添加一个条件，密码不等于指定值
            // 添加一个条件，字段名为PASSWORD，操作符为<>，值为value，字段名为password
            return (Criteria) this;
            // 返回当前对象
        }
        // 年龄为空

        public Criteria andPasswordNotEqualTo(String value) {
            addCriterion("PASSWORD <>", value, "password");
            return (Criteria) this;
        }
        // 年龄不为空

        public Criteria andPasswordGreaterThan(String value) {
            addCriterion("PASSWORD >", value, "password");
            return (Criteria) this;
        }
        // 年龄等于

        public Criteria andPasswordGreaterThanOrEqualTo(String value) {
        // 添加一个条件，密码小于指定值
            addCriterion("PASSWORD >=", value, "password");
            // 添加条件
        // 年龄不等于
            // 返回当前对象
            return (Criteria) this;
        }

        public Criteria andPasswordLessThan(String value) {
        // 年龄大于
            addCriterion("PASSWORD <", value, "password");
            return (Criteria) this;
        }

        public Criteria andPasswordLessThanOrEqualTo(String value) {
        // 年龄大于等于
            addCriterion("PASSWORD <=", value, "password");
            return (Criteria) this;
        }

        // 添加一个条件，密码不等于value
        // 年龄小于
        public Criteria andPasswordLike(String value) {
            addCriterion("PASSWORD like", value, "password");
            return (Criteria) this;
        }

        // 年龄小于等于
        public Criteria andPasswordNotLike(String value) {
            addCriterion("PASSWORD not like", value, "password");
            return (Criteria) this;
        }

        // 年龄在列表中
        public Criteria andPasswordIn(List<String> values) {
            addCriterion("PASSWORD in", values, "password");
            return (Criteria) this;
        }

        // 年龄不在列表中
        public Criteria andPasswordNotIn(List<String> values) {
            addCriterion("PASSWORD not in", values, "password");
            return (Criteria) this;
        }
        }
        // 年龄在范围内
        // 添加条件，密码不在value1和value2之间

        public Criteria andPasswordNotBetween(String value1, String value2) {
            addCriterion("PASSWORD not between", value1, value2, "password");
            return (Criteria) this;
        // 年龄不在范围内
        }

        public Criteria andAgeIsNull() {
            addCriterion("AGE is null");
            return (Criteria) this;
        // 性别为空
        }

        // 添加AGE等于value的条件
v            addCriterion("AGE is not null");

        // 性别不为空
        public Criteria andAgeEqualTo(Integer value) {
            addCriterion("AGE =", value, "age");
            return (Criteria) this;
        }

        // 性别等于
        public Criteria andAgeNotEqualTo(Integer value) {
            addCriterion("AGE <>", value, "age");
            return (Criteria) this;
        }
        // 添加年龄大于指定值的条件
        // 性别不等于

        public Criteria andAgeGreaterThan(Integer value) {
            // 添加年龄大于等于指定值的条件
            addCriterion("AGE >", value, "age");
            return (Criteria) this;
        // 性别大于
            addCriterion("AGE >=", value, "age");
            return (Criteria) this;
        }

        public Criteria andAgeLessThan(Integer value) {
        // 性别大于等于
            addCriterion("AGE <", value, "age");
            return (Criteria) this;
        }

        public Criteria andAgeLessThanOrEqualTo(Integer value) {
        // 性别小于
            addCriterion("AGE <=", value, "age");
            return (Criteria) this;
        }

        public Criteria andAgeIn(List<Integer> values) {
        // 根据年龄列表，添加不包含在列表中的条件
            addCriterion("AGE in", values, "age");
            // 添加条件
            return (Criteria) this;
            // 返回当前对象
        }

        public Criteria andAgeNotIn(List<Integer> values) {
            addCriterion("AGE not in", values, "age");
            return (Criteria) this;
        }

        // 添加年龄在value1和value2之间的条件
        public Criteria andAgeBetween(Integer value1, Integer value2) {
            // 添加条件
            addCriterion("AGE between", value1, value2, "age");
            // 返回当前对象
            return (Criteria) this;
        }

        public Criteria andAgeNotBetween(Integer value1, Integer value2) {
            addCriterion("AGE not between", value1, value2, "age");
            return (Criteria) this;
        }

        public Criteria andSexIsNull() {
            addCriterion("SEX is null");
            return (Criteria) this;
        }

        public Criteria andSexIsNotNull() {
        // 根据性别等于某个值进行查询
            addCriterion("SEX is not null");
            // 添加查询条件
            // 返回当前查询对象
            return (Criteria) this;
        // 根据性别等于某个值进行查询
        }
            // 添加查询条件，条件为SEX等于value

            // 返回当前Criteria对象
        public Criteria andSexEqualTo(Integer value) {
            addCriterion("SEX =", value, "sex");
            return (Criteria) this;
        }

        public Criteria andSexNotEqualTo(Integer value) {
            addCriterion("SEX <>", value, "sex");
            return (Criteria) this;
        }

        public Criteria andSexGreaterThan(Integer value) {
            addCriterion("SEX >", value, "sex");
            return (Criteria) this;
        }

        public Criteria andSexGreaterThanOrEqualTo(Integer value) {
            addCriterion("SEX >=", value, "sex");
            return (Criteria) this;
        }

        public Criteria andSexLessThan(Integer value) {
            addCriterion("SEX <", value, "sex");
            return (Criteria) this;
        // 添加一个条件，要求性别小于等于指定值
        // 添加性别小于等于条件
        }

        public Criteria andSexLessThanOrEqualTo(Integer value) {
v        public Criteria andSexBetween(Integer value1, Integer value2) {
            addCriterion("SEX between", value1, value2, "sex");
            return (Criteria) this;
        }

        // 添加条件，性别不在value1和value2之间
        public Criteria andSexNotBetween(Integer value1, Integer value2) {
            addCriterion("SEX not between", value1, value2, "sex");
            return (Criteria) this;
        }

        public Criteria andEmailIsNull() {
            addCriterion("EMAIL is null");
            return (Criteria) this;
        }

        public Criteria andEmailIsNotNull() {
            addCriterion("EMAIL is not null");
            return (Criteria) this;
        }

        public Criteria andEmailEqualTo(String value) {
            addCriterion("EMAIL =", value, "email");
            return (Criteria) this;
        }

        public Criteria andEmailNotEqualTo(String value) {
            addCriterion("EMAIL <>", value, "email");
            return (Criteria) this;
        }

        public Criteria andEmailGreaterThan(String value) {
            addCriterion("EMAIL >", value, "email");
            return (Criteria) this;
        }

        // 添加一个条件，要求email字段大于等于value
        public Criteria andEmailGreaterThanOrEqualTo(String value) {
            // 添加条件
            addCriterion("EMAIL >=", value, "email");
            // 返回当前对象
            return (Criteria) this;
        }

        // 添加一个条件，当email小于指定值时
        public Criteria andEmailLessThan(String value) {
            // 添加一个条件，当email小于指定值时
            addCriterion("EMAIL <", value, "email");
            // 返回当前对象
            return (Criteria) this;
        }

        public Criteria andEmailLessThanOrEqualTo(String value) {
            addCriterion("EMAIL <=", value, "email");
            return (Criteria) this;
        }

        public Criteria andEmailLike(String value) {
            addCriterion("EMAIL like", value, "email");
            return (Criteria) this;
        }

        public Criteria andEmailNotLike(String value) {
            addCriterion("EMAIL not like", value, "email");
            return (Criteria) this;
        }

        // 根据传入的values参数，添加EMAIL in的条件
        public Criteria andEmailIn(List<String> values) {
            addCriterion("EMAIL in", values, "email");
            return (Criteria) this;
        }

        // 根据email字段，添加一个条件，该条件表示email字段不在values列表中
        public Criteria andEmailNotIn(List<String> values) {
            addCriterion("EMAIL not in", values, "email");
            return (Criteria) this;
        }

        public Criteria andEmailBetween(String value1, String value2) {
            addCriterion("EMAIL between", value1, value2, "email");
            return (Criteria) this;
        // 添加email字段不介于value1和value2之间的条件
        }

        public Criteria andEmailNotBetween(String value1, String value2) {
            addCriterion("EMAIL not between", value1, value2, "email");
            return (Criteria) this;
        }

        // 添加一个条件，QQ字段为空
        public Criteria andQqIsNull() {
            addCriterion("QQ is null");
            return (Criteria) this;
        }

        // 添加一个条件，QQ字段不能为空
        public Criteria andQqIsNotNull() {
            addCriterion("QQ is not null");
            return (Criteria) this;
        }

        // 根据QQ字段等于某个值进行查询
        public Criteria andQqEqualTo(String value) {
            // 添加查询条件
            addCriterion("QQ =", value, "qq");
            // 返回当前Criteria对象
            return (Criteria) this;
        }

        public Criteria andQqNotEqualTo(String value) {
            addCriterion("QQ <>", value, "qq");
            return (Criteria) this;
        // 添加QQ大于指定值的条件
        }

        public Criteria andQqGreaterThan(String value) {
            addCriterion("QQ >", value, "qq");
        // 添加QQ大于等于指定值的条件
            return (Criteria) this;
        }

        // 添加一个条件，QQ大于等于value
        public Criteria andQqGreaterThanOrEqualTo(String value) {
            // 添加一个条件，QQ大于等于value
            addCriterion("QQ >=", value, "qq");
            // 返回当前对象
            return (Criteria) this;
        }

        // 添加一个条件，QQ小于指定值
        public Criteria andQqLessThan(String value) {
            // 添加一个条件，字段名为QQ，操作符为小于，值为指定值
            addCriterion("QQ <", value, "qq");
            // 返回当前对象
            return (Criteria) this;
        }

        // 添加一个条件，QQ小于等于value
        public Criteria andQqLessThanOrEqualTo(String value) {
            // 添加一个条件，QQ小于等于value
            addCriterion("QQ <=", value, "qq");
            // 返回当前对象
            return (Criteria) this;
        }

        public Criteria andQqLike(String value) {
            addCriterion("QQ like", value, "qq");
            return (Criteria) this;
        }

        // 添加一个条件，QQ字段不等于value
        public Criteria andQqNotLike(String value) {
            addCriterion("QQ not like", value, "qq");
            return (Criteria) this;
        }

        public Criteria andQqIn(List<String> values) {
            addCriterion("QQ in", values, "qq");
        // 根据传入的参数values，将QQ字段不包含在values中的条件添加到Criteria中
            return (Criteria) this;
        }

        public Criteria andQqNotIn(List<String> values) {
            addCriterion("QQ not in", values, "qq");
            return (Criteria) this;
        }

        // 添加QQ字段在value1和value2之间的条件
        public Criteria andQqBetween(String value1, String value2) {
            addCriterion("QQ between", value1, value2, "qq");
            return (Criteria) this;
        }

        // 添加一个QQ字段，其值不在value1和value2之间
        public Criteria andQqNotBetween(String value1, String value2) {
            addCriterion("QQ not between", value1, value2, "qq");
            return (Criteria) this;
        }

        // 添加一个条件，PHONE_NUMBER字段为空
        public Criteria andPhoneNumberIsNull() {
            addCriterion("PHONE_NUMBER is null");
            return (Criteria) this;
        }

        // 添加一个条件，PHONE_NUMBER字段不能为空
        public Criteria andPhoneNumberIsNotNull() {
            addCriterion("PHONE_NUMBER is not null");
            return (Criteria) this;
        }

        // 根据电话号码等于某个值进行查询
        public Criteria andPhoneNumberEqualTo(String value) {
            // 添加查询条件
            addCriterion("PHONE_NUMBER =", value, "phoneNumber");
            // 返回当前查询对象
            return (Criteria) this;
        }

        public Criteria andPhoneNumberNotEqualTo(String value) {
            addCriterion("PHONE_NUMBER <>", value, "phoneNumber");
            return (Criteria) this;
        }

        // 添加一个条件，PHONE_NUMBER大于value
        public Criteria andPhoneNumberGreaterThan(String value) {
            addCriterion("PHONE_NUMBER >", value, "phoneNumber");
            return (Criteria) this;
        }

        public Criteria andPhoneNumberGreaterThanOrEqualTo(String value) {
            addCriterion("PHONE_NUMBER >=", value, "phoneNumber");
            return (Criteria) this;
        }

        // 添加一个条件，PHONE_NUMBER字段的值小于value
        public Criteria andPhoneNumberLessThan(String value) {
            addCriterion("PHONE_NUMBER <", value, "phoneNumber");
            return (Criteria) this;
        }

        // 添加一个条件，当电话号码小于等于指定值时
        public Criteria andPhoneNumberLessThanOrEqualTo(String value) {
            // 添加条件
            addCriterion("PHONE_NUMBER <=", value, "phoneNumber");
            // 返回当前对象
            return (Criteria) this;
        }

        // 根据电话号码模糊查询
        public Criteria andPhoneNumberLike(String value) {
            // 添加查询条件
            addCriterion("PHONE_NUMBER like", value, "phoneNumber");
            // 返回当前对象
            return (Criteria) this;
        }

        // 根据电话号码不匹配的条件进行查询
        public Criteria andPhoneNumberNotLike(String value) {
            // 添加查询条件，电话号码不匹配
            addCriterion("PHONE_NUMBER not like", value, "phoneNumber");
            // 返回当前查询条件
            return (Criteria) this;
        }

        // 根据电话号码列表添加查询条件
        public Criteria andPhoneNumberIn(List<String> values) {
            // 添加查询条件
            addCriterion("PHONE_NUMBER in", values, "phoneNumber");
            // 返回当前查询条件
            return (Criteria) this;
        }

        public Criteria andPhoneNumberNotIn(List<String> values) {
            // 添加条件，PHONE_NUMBER 不在 values 中
            addCriterion("PHONE_NUMBER not in", values, "phoneNumber");
            // 返回当前 Criteria 对象
            return (Criteria) this;
        }

        // 添加PHONE_NUMBER字段的值在value1和value2之间的条件
        public Criteria andPhoneNumberBetween(String value1, String value2) {
            addCriterion("PHONE_NUMBER between", value1, value2, "phoneNumber");
            return (Criteria) this;
        }

        // 添加PHONE_NUMBER字段的值不在value1和value2之间的条件
        // 添加一个条件，判断电话号码是否在指定范围内
        public Criteria andPhoneNumberNotBetween(String value1, String value2) {
            // 添加条件，判断电话号码是否在指定范围内
            addCriterion("PHONE_NUMBER not between", value1, value2, "phoneNumber");
            // 返回当前对象
            return (Criteria) this;
        }

        // 添加一个条件，OFFICE_TEL字段为空
        // 添加一个条件，OFFICE_TEL字段为空
        public Criteria andOfficeTelIsNull() {
            addCriterion("OFFICE_TEL is null");
            return (Criteria) this;
        }

        // 添加条件，OFFICE_TEL字段不能为空
        public Criteria andOfficeTelIsNotNull() {
            addCriterion("OFFICE_TEL is not null");
            return (Criteria) this;
        }

        // 根据officeTel字段的值进行等于查询
        public Criteria andOfficeTelEqualTo(String value) {
            // 添加查询条件
            addCriterion("OFFICE_TEL =", value, "officeTel");
            // 返回当前Criteria对象
            return (Criteria) this;
        }

        // 添加一个条件，officeTel不等于value
        public Criteria andOfficeTelNotEqualTo(String value) {
            // 添加一个条件，officeTel不等于value
            addCriterion("OFFICE_TEL <>", value, "officeTel");
            // 返回当前Criteria对象
            return (Criteria) this;
        }



        // 添加一个条件，OFFICE_TEL字段大于等于value
        // 添加一个条件，OFFICE_TEL字段大于等于value
        public Criteria andOfficeTelGreaterThanOrEqualTo(String value) {
            addCriterion("OFFICE_TEL >=", value, "officeTel");
            return (Criteria) this;
        // 添加一个条件，OFFICE_TEL字段的值小于value
        }

        // 添加一个条件，OFFICE_TEL字段的值小于value
        public Criteria andOfficeTelLessThan(String value) {
            addCriterion("OFFICE_TEL <", value, "officeTel");
            return (Criteria) this;
        }

        // 添加条件，OFFICE_TEL字段小于等于value
        public Criteria andOfficeTelLessThanOrEqualTo(String value) {
            addCriterion("OFFICE_TEL <=", value, "officeTel");
            return (Criteria) this;
        }

        public Criteria andOfficeTelLike(String value) {
            addCriterion("OFFICE_TEL like", value, "officeTel");
            return (Criteria) this;
        }

        // 根据officeTel字段，添加一个不等于value的条件
        // 根据officeTel字段，添加一个不等于value的条件
        public Criteria andOfficeTelNotLike(String value) {
            addCriterion("OFFICE_TEL not like", value, "officeTel");
            return (Criteria) this;
        }

        // 根据传入的参数values，将OFFICE_TEL字段添加到查询条件中
        // 根据传入的参数values，将OFFICE_TEL字段添加到查询条件中
        public Criteria andOfficeTelIn(List<String> values) {
            addCriterion("OFFICE_TEL in", values, "officeTel");
            return (Criteria) this;
        }

        // 根据officeTel字段，将values中的值排除在外
        public Criteria andOfficeTelNotIn(List<String> values) {
            addCriterion("OFFICE_TEL not in", values, "officeTel");
            return (Criteria) this;
        }

        // 添加一个条件，OFFICE_TEL字段在value1和value2之间
        // 添加一个条件，OFFICE_TEL字段在value1和value2之间
        public Criteria andOfficeTelBetween(String value1, String value2) {
            addCriterion("OFFICE_TEL between", value1, value2, "officeTel");
            return (Criteria) this;
        }

        // 添加一个条件，officeTel字段的值不在value1和value2之间
        public Criteria andOfficeTelNotBetween(String value1, String value2) {
            addCriterion("OFFICE_TEL not between", value1, value2, "officeTel");
            return (Criteria) this;
        }

        // 添加条件，LOCKED字段为空
        public Criteria andLockedIsNull() {
            addCriterion("LOCKED is null");
            return (Criteria) this;
        }

        public Criteria andLockedIsNotNull() {
            // 添加条件，LOCKED字段不为空
            addCriterion("LOCKED is not null");
            // 返回当前Criteria对象
            return (Criteria) this;
        }

        // 设置LOCKED字段的值为value
        // 根据传入的value值，设置LOCKED字段的值为value，并返回当前Criteria对象
        public Criteria andLockedEqualTo(Integer value) {
            // 添加条件，LOCKED字段的值为value
            addCriterion("LOCKED =", value, "locked");
            // 返回当前Criteria对象
            return (Criteria) this;
        }

        // 设置LOCKED字段的值不等于value
        // 根据传入的value值，添加一个条件，判断locked字段的值是否不等于value
        public Criteria andLockedNotEqualTo(Integer value) {
            addCriterion("LOCKED <>", value, "locked");
            return (Criteria) this;
        }

        // 设置LOCKED字段的值大于value
        // 添加一个条件，LOCKED字段的值大于value
        // 添加一个条件，LOCKED字段的值大于value
        public Criteria andLockedGreaterThan(Integer value) {
            addCriterion("LOCKED >", value, "locked");
            return (Criteria) this;
        }

        // 添加一个条件，LOCKED字段大于等于value
        // 添加一个条件，LOCKED字段大于等于value
        public Criteria andLockedGreaterThanOrEqualTo(Integer value) {
            addCriterion("LOCKED >=", value, "locked");
            return (Criteria) this;
        }

        // 添加一个条件，LOCKED字段小于value
        public Criteria andLockedLessThan(Integer value) {
            addCriterion("LOCKED <", value, "locked");
            return (Criteria) this;
        }

        // 添加一个条件，LOCKED字段小于等于value
        public Criteria andLockedLessThanOrEqualTo(Integer value) {
            addCriterion("LOCKED <=", value, "locked");
            return (Criteria) this;
        }

        // 根据传入的值，添加LOCKED in条件
        public Criteria andLockedIn(List<Integer> values) {
            addCriterion("LOCKED in", values, "locked");
            return (Criteria) this;
        }

        // 根据传入的值，添加一个条件，判断LOCKED字段是否不在传入的值列表中
        public Criteria andLockedNotIn(List<Integer> values) {
            // 添加一个条件，判断LOCKED字段是否不在传入的值列表中
            addCriterion("LOCKED not in", values, "locked");
            // 返回当前Criteria对象
            return (Criteria) this;
        }

        // 添加一个条件，LOCKED字段在value1和value2之间
        public Criteria andLockedBetween(Integer value1, Integer value2) {
            addCriterion("LOCKED between", value1, value2, "locked");
            return (Criteria) this;
        }

        // 添加一个条件，LOCKED字段的值不在value1和value2之间
        // 添加一个条件，LOCKED字段的值不在value1和value2之间
        public Criteria andLockedNotBetween(Integer value1, Integer value2) {
            addCriterion("LOCKED not between", value1, value2, "locked");
            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();
            // 将传入的条件字符串赋值给成员变量condition
            this.condition = condition;
            // 将typeHandler赋值为null
            this.typeHandler = null;
            // 将noValue赋值为true
            this.noValue = true;
        }

        // 构造函数，用于创建Criterion对象
        protected Criterion(String condition, Object value, String typeHandler) {
            super();
            // 设置条件
            this.condition = condition;
            // 设置值
            this.value = value;
            // 设置类型处理器
            this.typeHandler = typeHandler;
            // 判断值是否为List类型
            if (value instanceof List<?>) {
                // 如果是List类型，则设置listValue为true
                this.listValue = true;
            } else {
                // 否则，设置singleValue为true
                this.singleValue = true;
            }
        }

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

        // 构造函数，用于创建Criterion对象
        protected Criterion(String condition, Object value, Object secondValue, String typeHandler) {
            super();
            // 设置条件
            this.condition = condition;
            // 设置值
            this.value = value;
            // 设置第二个值
            this.secondValue = secondValue;
            // 设置类型处理器
            this.typeHandler = typeHandler;
            // 设置betweenValue为true
            this.betweenValue = true;
        }

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