package com.mortals.xhx.base.system.gentable.model;

import java.util.List;
import java.util.Date;

/**
*
* Description:GentableColumn
* date: 2021-9-28 10:10:15
*/
public class GentableColumnQuery extends GentableColumnEntity{
    private static final long serialVersionUID = 1632795015378L;
    /** 开始 ID，主键，自增长 */
    private Long idStart;

    /** 结束 ID，主键，自增长 */
    private Long idEnd;

    /** 增加 ID，主键，自增长 */
    private Long idIncrement;

    /** ID，主键，自增长 */
    private List <Long> idList;

    /** 开始 所属表编号 */
    private Long tableIdStart;

    /** 结束 所属表编号 */
    private Long tableIdEnd;

    /** 增加 所属表编号 */
    private Long tableIdIncrement;

    /** 所属表编号 */
    private List <Long> tableIdList;


    /** 列名称 */
    private List<String> columnNameList;

    /** 列描述 */
    private List<String> columnCommentList;

    /** 列类型 */
    private List<String> columnTypeList;

    /** JAVA类型 */
    private List<String> javaTypeList;

    /** JAVA字段名 */
    private List<String> javaFieldList;

    /** 开始 是否primaryKey（0否，1 是） */
    private Integer isPrimaryKeyStart;

    /** 结束 是否primaryKey（0否，1 是） */
    private Integer isPrimaryKeyEnd;

    /** 增加 是否primaryKey（0否，1 是） */
    private Integer isPrimaryKeyIncrement;

    /** 是否primaryKey（0否，1 是） */
    private List <Integer> isPrimaryKeyList;

    /** 开始 是否自增（0否，1 是） */
    private Integer isIncrementStart;

    /** 结束 是否自增（0否，1 是） */
    private Integer isIncrementEnd;

    /** 增加 是否自增（0否，1 是） */
    private Integer isIncrementIncrement;

    /** 是否自增（0否，1 是） */
    private List <Integer> isIncrementList;

    /** 开始 是否必填（0否，1 是） */
    private Integer isRequiredStart;

    /** 结束 是否必填（0否，1 是） */
    private Integer isRequiredEnd;

    /** 增加 是否必填（0否，1 是） */
    private Integer isRequiredIncrement;

    /** 是否必填（0否，1 是） */
    private List <Integer> isRequiredList;

    /** 开始 是否为插入字段（0否，1 是） */
    private Integer isInsertStart;

    /** 结束 是否为插入字段（0否，1 是） */
    private Integer isInsertEnd;

    /** 增加 是否为插入字段（0否，1 是） */
    private Integer isInsertIncrement;

    /** 是否为插入字段（0否，1 是） */
    private List <Integer> isInsertList;

    /** 开始 是否编辑字段（0否，1 是） */
    private Integer isEditStart;

    /** 结束 是否编辑字段（0否，1 是） */
    private Integer isEditEnd;

    /** 增加 是否编辑字段（0否，1 是） */
    private Integer isEditIncrement;

    /** 是否编辑字段（0否，1 是） */
    private List <Integer> isEditList;

    /** 开始 是否列表字段（0否，1 是） */
    private Integer isListStart;

    /** 结束 是否列表字段（0否，1 是） */
    private Integer isListEnd;

    /** 增加 是否列表字段（0否，1 是） */
    private Integer isListIncrement;

    /** 是否列表字段（0否，1 是） */
    private List <Integer> isListList;

    /** 开始 是否查询字段（0否，1 是） */
    private Integer isQueryStart;

    /** 结束 是否查询字段（0否，1 是） */
    private Integer isQueryEnd;

    /** 增加 是否查询字段（0否，1 是） */
    private Integer isQueryIncrement;

    /** 是否查询字段（0否，1 是） */
    private List <Integer> isQueryList;

    /** 开始 显示类型（1.文本框、2.文本域、3.下拉框、4.复选框、5.单选框、6.日期控件） */
    private Integer htmlTypeStart;

    /** 结束 显示类型（1.文本框、2.文本域、3.下拉框、4.复选框、5.单选框、6.日期控件） */
    private Integer htmlTypeEnd;

    /** 增加 显示类型（1.文本框、2.文本域、3.下拉框、4.复选框、5.单选框、6.日期控件） */
    private Integer htmlTypeIncrement;

    /** 显示类型（1.文本框、2.文本域、3.下拉框、4.复选框、5.单选框、6.日期控件） */
    private List <Integer> htmlTypeList;

    /** 开始 排序 */
    private Integer sortStart;

    /** 结束 排序 */
    private Integer sortEnd;

    /** 增加 排序 */
    private Integer sortIncrement;

    /** 排序 */
    private List <Integer> sortList;
    /** 开始 变更时间 */
    private String updateTimeStart;

    /** 结束 变更时间 */
    private String updateTimeEnd;

    /** 变更用户loginName */
    private List<String> updateUserList;
    /** 开始 创建时间 */
    private String createTimeStart;

    /** 结束 创建时间 */
    private String createTimeEnd;

    /** 创建用户loginName */
    private List<String> createUserList;

    /** OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4) */
    private List<GentableColumnQuery> orConditionList;

    /** AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4) */
    private List<GentableColumnQuery> andConditionList;


    public GentableColumnQuery(){
    }

    /**
    * 获取 开始 ID，主键，自增长
    * @return idStart
    */
    public Long getIdStart(){
    return this.idStart;
    }

    /**
    * 设置 开始 ID，主键，自增长
    * @param idStart
    */
    public void setIdStart(Long idStart){
    this.idStart = idStart;
    }

    /**
    * 获取 结束 ID，主键，自增长
    * @return idEnd
    */
    public Long getIdEnd(){
    return this.idEnd;
    }

    /**
    * 设置 结束 ID，主键，自增长
    * @param idEnd
    */
    public void setIdEnd(Long idEnd){
    this.idEnd = idEnd;
    }

    /**
    * 获取 增加 ID，主键，自增长
    * @return idIncrement
    */
    public Long getIdIncrement(){
    return this.idIncrement;
    }

    /**
    * 设置 增加 ID，主键，自增长
    * @param idIncrement
    */
    public void setIdIncrement(Long idIncrement){
    this.idIncrement = idIncrement;
    }

    /**
    * 获取 ID，主键，自增长
    * @return idList
    */
    public List<Long> getIdList(){
    return this.idList;
    }

    /**
    * 设置 ID，主键，自增长
    * @param idList
    */
    public void setIdList(List<Long> idList){
        this.idList = idList;
        }
    /**
    * 获取 开始 所属表编号
    * @return tableIdStart
    */
    public Long getTableIdStart(){
    return this.tableIdStart;
    }

    /**
    * 设置 开始 所属表编号
    * @param tableIdStart
    */
    public void setTableIdStart(Long tableIdStart){
    this.tableIdStart = tableIdStart;
    }

    /**
    * 获取 结束 所属表编号
    * @return tableIdEnd
    */
    public Long getTableIdEnd(){
    return this.tableIdEnd;
    }

    /**
    * 设置 结束 所属表编号
    * @param tableIdEnd
    */
    public void setTableIdEnd(Long tableIdEnd){
    this.tableIdEnd = tableIdEnd;
    }

    /**
    * 获取 增加 所属表编号
    * @return tableIdIncrement
    */
    public Long getTableIdIncrement(){
    return this.tableIdIncrement;
    }

    /**
    * 设置 增加 所属表编号
    * @param tableIdIncrement
    */
    public void setTableIdIncrement(Long tableIdIncrement){
    this.tableIdIncrement = tableIdIncrement;
    }

    /**
    * 获取 所属表编号
    * @return tableIdList
    */
    public List<Long> getTableIdList(){
    return this.tableIdList;
    }

    /**
    * 设置 所属表编号
    * @param tableIdList
    */
    public void setTableIdList(List<Long> tableIdList){
        this.tableIdList = tableIdList;
        }
    /**
    * 获取 列名称
    * @return columnNameList
    */
    public List<String> getColumnNameList(){
        return this.columnNameList;
    }

    /**
    * 设置 列名称
    * @param columnNameList
    */
    public void setColumnNameList(List<String> columnNameList){
        this.columnNameList = columnNameList;
    }
    /**
    * 获取 列描述
    * @return columnCommentList
    */
    public List<String> getColumnCommentList(){
        return this.columnCommentList;
    }

    /**
    * 设置 列描述
    * @param columnCommentList
    */
    public void setColumnCommentList(List<String> columnCommentList){
        this.columnCommentList = columnCommentList;
    }
    /**
    * 获取 列类型
    * @return columnTypeList
    */
    public List<String> getColumnTypeList(){
        return this.columnTypeList;
    }

    /**
    * 设置 列类型
    * @param columnTypeList
    */
    public void setColumnTypeList(List<String> columnTypeList){
        this.columnTypeList = columnTypeList;
    }
    /**
    * 获取 JAVA类型
    * @return javaTypeList
    */
    public List<String> getJavaTypeList(){
        return this.javaTypeList;
    }

    /**
    * 设置 JAVA类型
    * @param javaTypeList
    */
    public void setJavaTypeList(List<String> javaTypeList){
        this.javaTypeList = javaTypeList;
    }
    /**
    * 获取 JAVA字段名
    * @return javaFieldList
    */
    public List<String> getJavaFieldList(){
        return this.javaFieldList;
    }

    /**
    * 设置 JAVA字段名
    * @param javaFieldList
    */
    public void setJavaFieldList(List<String> javaFieldList){
        this.javaFieldList = javaFieldList;
    }
    /**
    * 获取 开始 是否primaryKey（0否，1 是）
    * @return isPrimaryKeyStart
    */
    public Integer getIsPrimaryKeyStart(){
        return this.isPrimaryKeyStart;
    }

    /**
    * 设置 开始 是否primaryKey（0否，1 是）
    * @param isPrimaryKeyStart
    */
    public void setIsPrimaryKeyStart(Integer isPrimaryKeyStart){
        this.isPrimaryKeyStart = isPrimaryKeyStart;
    }

    /**
    * 获取 结束 是否primaryKey（0否，1 是）
    * @return isPrimaryKeyEnd
    */
    public Integer getIsPrimaryKeyEnd(){
        return this.isPrimaryKeyEnd;
    }

    /**
    * 设置 结束 是否primaryKey（0否，1 是）
    * @param isPrimaryKeyEnd
    */
    public void setIsPrimaryKeyEnd(Integer isPrimaryKeyEnd){
        this.isPrimaryKeyEnd = isPrimaryKeyEnd;
    }

    /**
    * 获取 增加 是否primaryKey（0否，1 是）
    * @return isPrimaryKeyIncrement
    */
    public Integer getIsPrimaryKeyIncrement(){
        return this.isPrimaryKeyIncrement;
    }

    /**
    * 设置 增加 是否primaryKey（0否，1 是）
    * @param isPrimaryKeyIncrement
    */
    public void setIsPrimaryKeyIncrement(Integer isPrimaryKeyIncrement){
        this.isPrimaryKeyIncrement = isPrimaryKeyIncrement;
    }

    /**
    * 获取 是否primaryKey（0否，1 是）
    * @return isPrimaryKeyList
    */
    public List<Integer> getIsPrimaryKeyList(){
        return this.isPrimaryKeyList;
    }

    /**
    * 设置 是否primaryKey（0否，1 是）
    * @param isPrimaryKeyList
    */
    public void setIsPrimaryKeyList(List<Integer> isPrimaryKeyList){
        this.isPrimaryKeyList = isPrimaryKeyList;
    }
    /**
    * 获取 开始 是否自增（0否，1 是）
    * @return isIncrementStart
    */
    public Integer getIsIncrementStart(){
        return this.isIncrementStart;
    }

    /**
    * 设置 开始 是否自增（0否，1 是）
    * @param isIncrementStart
    */
    public void setIsIncrementStart(Integer isIncrementStart){
        this.isIncrementStart = isIncrementStart;
    }

    /**
    * 获取 结束 是否自增（0否，1 是）
    * @return isIncrementEnd
    */
    public Integer getIsIncrementEnd(){
        return this.isIncrementEnd;
    }

    /**
    * 设置 结束 是否自增（0否，1 是）
    * @param isIncrementEnd
    */
    public void setIsIncrementEnd(Integer isIncrementEnd){
        this.isIncrementEnd = isIncrementEnd;
    }

    /**
    * 获取 增加 是否自增（0否，1 是）
    * @return isIncrementIncrement
    */
    public Integer getIsIncrementIncrement(){
        return this.isIncrementIncrement;
    }

    /**
    * 设置 增加 是否自增（0否，1 是）
    * @param isIncrementIncrement
    */
    public void setIsIncrementIncrement(Integer isIncrementIncrement){
        this.isIncrementIncrement = isIncrementIncrement;
    }

    /**
    * 获取 是否自增（0否，1 是）
    * @return isIncrementList
    */
    public List<Integer> getIsIncrementList(){
        return this.isIncrementList;
    }

    /**
    * 设置 是否自增（0否，1 是）
    * @param isIncrementList
    */
    public void setIsIncrementList(List<Integer> isIncrementList){
        this.isIncrementList = isIncrementList;
    }
    /**
    * 获取 开始 是否必填（0否，1 是）
    * @return isRequiredStart
    */
    public Integer getIsRequiredStart(){
        return this.isRequiredStart;
    }

    /**
    * 设置 开始 是否必填（0否，1 是）
    * @param isRequiredStart
    */
    public void setIsRequiredStart(Integer isRequiredStart){
        this.isRequiredStart = isRequiredStart;
    }

    /**
    * 获取 结束 是否必填（0否，1 是）
    * @return isRequiredEnd
    */
    public Integer getIsRequiredEnd(){
        return this.isRequiredEnd;
    }

    /**
    * 设置 结束 是否必填（0否，1 是）
    * @param isRequiredEnd
    */
    public void setIsRequiredEnd(Integer isRequiredEnd){
        this.isRequiredEnd = isRequiredEnd;
    }

    /**
    * 获取 增加 是否必填（0否，1 是）
    * @return isRequiredIncrement
    */
    public Integer getIsRequiredIncrement(){
        return this.isRequiredIncrement;
    }

    /**
    * 设置 增加 是否必填（0否，1 是）
    * @param isRequiredIncrement
    */
    public void setIsRequiredIncrement(Integer isRequiredIncrement){
        this.isRequiredIncrement = isRequiredIncrement;
    }

    /**
    * 获取 是否必填（0否，1 是）
    * @return isRequiredList
    */
    public List<Integer> getIsRequiredList(){
        return this.isRequiredList;
    }

    /**
    * 设置 是否必填（0否，1 是）
    * @param isRequiredList
    */
    public void setIsRequiredList(List<Integer> isRequiredList){
        this.isRequiredList = isRequiredList;
    }
    /**
    * 获取 开始 是否为插入字段（0否，1 是）
    * @return isInsertStart
    */
    public Integer getIsInsertStart(){
        return this.isInsertStart;
    }

    /**
    * 设置 开始 是否为插入字段（0否，1 是）
    * @param isInsertStart
    */
    public void setIsInsertStart(Integer isInsertStart){
        this.isInsertStart = isInsertStart;
    }

    /**
    * 获取 结束 是否为插入字段（0否，1 是）
    * @return isInsertEnd
    */
    public Integer getIsInsertEnd(){
        return this.isInsertEnd;
    }

    /**
    * 设置 结束 是否为插入字段（0否，1 是）
    * @param isInsertEnd
    */
    public void setIsInsertEnd(Integer isInsertEnd){
        this.isInsertEnd = isInsertEnd;
    }

    /**
    * 获取 增加 是否为插入字段（0否，1 是）
    * @return isInsertIncrement
    */
    public Integer getIsInsertIncrement(){
        return this.isInsertIncrement;
    }

    /**
    * 设置 增加 是否为插入字段（0否，1 是）
    * @param isInsertIncrement
    */
    public void setIsInsertIncrement(Integer isInsertIncrement){
        this.isInsertIncrement = isInsertIncrement;
    }

    /**
    * 获取 是否为插入字段（0否，1 是）
    * @return isInsertList
    */
    public List<Integer> getIsInsertList(){
        return this.isInsertList;
    }

    /**
    * 设置 是否为插入字段（0否，1 是）
    * @param isInsertList
    */
    public void setIsInsertList(List<Integer> isInsertList){
        this.isInsertList = isInsertList;
    }
    /**
    * 获取 开始 是否编辑字段（0否，1 是）
    * @return isEditStart
    */
    public Integer getIsEditStart(){
        return this.isEditStart;
    }

    /**
    * 设置 开始 是否编辑字段（0否，1 是）
    * @param isEditStart
    */
    public void setIsEditStart(Integer isEditStart){
        this.isEditStart = isEditStart;
    }

    /**
    * 获取 结束 是否编辑字段（0否，1 是）
    * @return isEditEnd
    */
    public Integer getIsEditEnd(){
        return this.isEditEnd;
    }

    /**
    * 设置 结束 是否编辑字段（0否，1 是）
    * @param isEditEnd
    */
    public void setIsEditEnd(Integer isEditEnd){
        this.isEditEnd = isEditEnd;
    }

    /**
    * 获取 增加 是否编辑字段（0否，1 是）
    * @return isEditIncrement
    */
    public Integer getIsEditIncrement(){
        return this.isEditIncrement;
    }

    /**
    * 设置 增加 是否编辑字段（0否，1 是）
    * @param isEditIncrement
    */
    public void setIsEditIncrement(Integer isEditIncrement){
        this.isEditIncrement = isEditIncrement;
    }

    /**
    * 获取 是否编辑字段（0否，1 是）
    * @return isEditList
    */
    public List<Integer> getIsEditList(){
        return this.isEditList;
    }

    /**
    * 设置 是否编辑字段（0否，1 是）
    * @param isEditList
    */
    public void setIsEditList(List<Integer> isEditList){
        this.isEditList = isEditList;
    }
    /**
    * 获取 开始 是否列表字段（0否，1 是）
    * @return isListStart
    */
    public Integer getIsListStart(){
        return this.isListStart;
    }

    /**
    * 设置 开始 是否列表字段（0否，1 是）
    * @param isListStart
    */
    public void setIsListStart(Integer isListStart){
        this.isListStart = isListStart;
    }

    /**
    * 获取 结束 是否列表字段（0否，1 是）
    * @return isListEnd
    */
    public Integer getIsListEnd(){
        return this.isListEnd;
    }

    /**
    * 设置 结束 是否列表字段（0否，1 是）
    * @param isListEnd
    */
    public void setIsListEnd(Integer isListEnd){
        this.isListEnd = isListEnd;
    }

    /**
    * 获取 增加 是否列表字段（0否，1 是）
    * @return isListIncrement
    */
    public Integer getIsListIncrement(){
        return this.isListIncrement;
    }

    /**
    * 设置 增加 是否列表字段（0否，1 是）
    * @param isListIncrement
    */
    public void setIsListIncrement(Integer isListIncrement){
        this.isListIncrement = isListIncrement;
    }

    /**
    * 获取 是否列表字段（0否，1 是）
    * @return isListList
    */
    public List<Integer> getIsListList(){
        return this.isListList;
    }

    /**
    * 设置 是否列表字段（0否，1 是）
    * @param isListList
    */
    public void setIsListList(List<Integer> isListList){
        this.isListList = isListList;
    }
    /**
    * 获取 开始 是否查询字段（0否，1 是）
    * @return isQueryStart
    */
    public Integer getIsQueryStart(){
        return this.isQueryStart;
    }

    /**
    * 设置 开始 是否查询字段（0否，1 是）
    * @param isQueryStart
    */
    public void setIsQueryStart(Integer isQueryStart){
        this.isQueryStart = isQueryStart;
    }

    /**
    * 获取 结束 是否查询字段（0否，1 是）
    * @return isQueryEnd
    */
    public Integer getIsQueryEnd(){
        return this.isQueryEnd;
    }

    /**
    * 设置 结束 是否查询字段（0否，1 是）
    * @param isQueryEnd
    */
    public void setIsQueryEnd(Integer isQueryEnd){
        this.isQueryEnd = isQueryEnd;
    }

    /**
    * 获取 增加 是否查询字段（0否，1 是）
    * @return isQueryIncrement
    */
    public Integer getIsQueryIncrement(){
        return this.isQueryIncrement;
    }

    /**
    * 设置 增加 是否查询字段（0否，1 是）
    * @param isQueryIncrement
    */
    public void setIsQueryIncrement(Integer isQueryIncrement){
        this.isQueryIncrement = isQueryIncrement;
    }

    /**
    * 获取 是否查询字段（0否，1 是）
    * @return isQueryList
    */
    public List<Integer> getIsQueryList(){
        return this.isQueryList;
    }

    /**
    * 设置 是否查询字段（0否，1 是）
    * @param isQueryList
    */
    public void setIsQueryList(List<Integer> isQueryList){
        this.isQueryList = isQueryList;
    }
    /**
    * 获取 开始 显示类型（1.文本框、2.文本域、3.下拉框、4.复选框、5.单选框、6.日期控件）
    * @return htmlTypeStart
    */
    public Integer getHtmlTypeStart(){
        return this.htmlTypeStart;
    }

    /**
    * 设置 开始 显示类型（1.文本框、2.文本域、3.下拉框、4.复选框、5.单选框、6.日期控件）
    * @param htmlTypeStart
    */
    public void setHtmlTypeStart(Integer htmlTypeStart){
        this.htmlTypeStart = htmlTypeStart;
    }

    /**
    * 获取 结束 显示类型（1.文本框、2.文本域、3.下拉框、4.复选框、5.单选框、6.日期控件）
    * @return htmlTypeEnd
    */
    public Integer getHtmlTypeEnd(){
        return this.htmlTypeEnd;
    }

    /**
    * 设置 结束 显示类型（1.文本框、2.文本域、3.下拉框、4.复选框、5.单选框、6.日期控件）
    * @param htmlTypeEnd
    */
    public void setHtmlTypeEnd(Integer htmlTypeEnd){
        this.htmlTypeEnd = htmlTypeEnd;
    }

    /**
    * 获取 增加 显示类型（1.文本框、2.文本域、3.下拉框、4.复选框、5.单选框、6.日期控件）
    * @return htmlTypeIncrement
    */
    public Integer getHtmlTypeIncrement(){
        return this.htmlTypeIncrement;
    }

    /**
    * 设置 增加 显示类型（1.文本框、2.文本域、3.下拉框、4.复选框、5.单选框、6.日期控件）
    * @param htmlTypeIncrement
    */
    public void setHtmlTypeIncrement(Integer htmlTypeIncrement){
        this.htmlTypeIncrement = htmlTypeIncrement;
    }

    /**
    * 获取 显示类型（1.文本框、2.文本域、3.下拉框、4.复选框、5.单选框、6.日期控件）
    * @return htmlTypeList
    */
    public List<Integer> getHtmlTypeList(){
        return this.htmlTypeList;
    }

    /**
    * 设置 显示类型（1.文本框、2.文本域、3.下拉框、4.复选框、5.单选框、6.日期控件）
    * @param htmlTypeList
    */
    public void setHtmlTypeList(List<Integer> htmlTypeList){
        this.htmlTypeList = htmlTypeList;
    }
    /**
    * 获取 开始 排序
    * @return sortStart
    */
    public Integer getSortStart(){
        return this.sortStart;
    }

    /**
    * 设置 开始 排序
    * @param sortStart
    */
    public void setSortStart(Integer sortStart){
        this.sortStart = sortStart;
    }

    /**
    * 获取 结束 排序
    * @return sortEnd
    */
    public Integer getSortEnd(){
        return this.sortEnd;
    }

    /**
    * 设置 结束 排序
    * @param sortEnd
    */
    public void setSortEnd(Integer sortEnd){
        this.sortEnd = sortEnd;
    }

    /**
    * 获取 增加 排序
    * @return sortIncrement
    */
    public Integer getSortIncrement(){
        return this.sortIncrement;
    }

    /**
    * 设置 增加 排序
    * @param sortIncrement
    */
    public void setSortIncrement(Integer sortIncrement){
        this.sortIncrement = sortIncrement;
    }

    /**
    * 获取 排序
    * @return sortList
    */
    public List<Integer> getSortList(){
        return this.sortList;
    }

    /**
    * 设置 排序
    * @param sortList
    */
    public void setSortList(List<Integer> sortList){
        this.sortList = sortList;
    }
    /**
    * 获取 开始 变更时间
    * @return updateTimeStart
    */
    public String getUpdateTimeStart(){
    return this.updateTimeStart;
    }

    /**
    * 设置 开始 变更时间
    * @param updateTimeStart
    */
    public void setUpdateTimeStart(String updateTimeStart){
    this.updateTimeStart = updateTimeStart;
    }

    /**
    * 获取 结束 变更时间
    * @return updateTimeEnd
    */
    public String getUpdateTimeEnd(){
    return this.updateTimeEnd;
    }

    /**
    * 设置 结束 变更时间
    * @param updateTimeEnd
    */
    public void setUpdateTimeEnd(String updateTimeEnd){
    this.updateTimeEnd = updateTimeEnd;
    }
    /**
    * 获取 变更用户loginName
    * @return updateUserList
    */
    public List<String> getUpdateUserList(){
        return this.updateUserList;
    }

    /**
    * 设置 变更用户loginName
    * @param updateUserList
    */
    public void setUpdateUserList(List<String> updateUserList){
        this.updateUserList = updateUserList;
    }
    /**
    * 获取 开始 创建时间
    * @return createTimeStart
    */
    public String getCreateTimeStart(){
    return this.createTimeStart;
    }

    /**
    * 设置 开始 创建时间
    * @param createTimeStart
    */
    public void setCreateTimeStart(String createTimeStart){
    this.createTimeStart = createTimeStart;
    }

    /**
    * 获取 结束 创建时间
    * @return createTimeEnd
    */
    public String getCreateTimeEnd(){
    return this.createTimeEnd;
    }

    /**
    * 设置 结束 创建时间
    * @param createTimeEnd
    */
    public void setCreateTimeEnd(String createTimeEnd){
    this.createTimeEnd = createTimeEnd;
    }
    /**
    * 获取 创建用户loginName
    * @return createUserList
    */
    public List<String> getCreateUserList(){
        return this.createUserList;
    }

    /**
    * 设置 创建用户loginName
    * @param createUserList
    */
    public void setCreateUserList(List<String> createUserList){
        this.createUserList = createUserList;
    }


	/**
    * 设置  ID，主键，自增长
    * @param id
    */
    public GentableColumnQuery id(Long id){
	    setId(id);
		return this;
    }
	
	 /**
    * 设置 开始 ID，主键，自增长
    * @param idStart
    */
    public GentableColumnQuery idStart(Long idStart){
		this.idStart = idStart;
		return this;
    }

    /**
    * 设置 结束 ID，主键，自增长
    * @param idEnd
    */
    public GentableColumnQuery idEnd(Long idEnd){
		this.idEnd = idEnd;
		return this;
    }

    /**
    * 设置 增加 ID，主键，自增长
    * @param idIncrement
    */
    public GentableColumnQuery idIncrement(Long idIncrement){
		this.idIncrement = idIncrement;
		return this;
    }

    /**
    * 设置 ID，主键，自增长
    * @param idList
    */
    public GentableColumnQuery idList(List<Long> idList){
        this.idList = idList;
		return this;
        }

	/**
    * 设置  所属表编号
    * @param tableId
    */
    public GentableColumnQuery tableId(Long tableId){
	    setTableId(tableId);
		return this;
    }
	
	 /**
    * 设置 开始 所属表编号
    * @param tableIdStart
    */
    public GentableColumnQuery tableIdStart(Long tableIdStart){
		this.tableIdStart = tableIdStart;
		return this;
    }

    /**
    * 设置 结束 所属表编号
    * @param tableIdEnd
    */
    public GentableColumnQuery tableIdEnd(Long tableIdEnd){
		this.tableIdEnd = tableIdEnd;
		return this;
    }

    /**
    * 设置 增加 所属表编号
    * @param tableIdIncrement
    */
    public GentableColumnQuery tableIdIncrement(Long tableIdIncrement){
		this.tableIdIncrement = tableIdIncrement;
		return this;
    }

    /**
    * 设置 所属表编号
    * @param tableIdList
    */
    public GentableColumnQuery tableIdList(List<Long> tableIdList){
        this.tableIdList = tableIdList;
		return this;
        }
	/**
    * 设置 列名称
    * @param columnName
    */
    public GentableColumnQuery columnName(String columnName){
        setColumnName(columnName);
		return this;
    }


    /**
    * 设置 列名称
    * @param columnNameList
    */
    public GentableColumnQuery columnNameList(List<String> columnNameList){
        this.columnNameList = columnNameList;
		return this;
    }
	/**
    * 设置 列描述
    * @param columnComment
    */
    public GentableColumnQuery columnComment(String columnComment){
        setColumnComment(columnComment);
		return this;
    }


    /**
    * 设置 列描述
    * @param columnCommentList
    */
    public GentableColumnQuery columnCommentList(List<String> columnCommentList){
        this.columnCommentList = columnCommentList;
		return this;
    }
	/**
    * 设置 列类型
    * @param columnType
    */
    public GentableColumnQuery columnType(String columnType){
        setColumnType(columnType);
		return this;
    }


    /**
    * 设置 列类型
    * @param columnTypeList
    */
    public GentableColumnQuery columnTypeList(List<String> columnTypeList){
        this.columnTypeList = columnTypeList;
		return this;
    }
	/**
    * 设置 JAVA类型
    * @param javaType
    */
    public GentableColumnQuery javaType(String javaType){
        setJavaType(javaType);
		return this;
    }


    /**
    * 设置 JAVA类型
    * @param javaTypeList
    */
    public GentableColumnQuery javaTypeList(List<String> javaTypeList){
        this.javaTypeList = javaTypeList;
		return this;
    }
	/**
    * 设置 JAVA字段名
    * @param javaField
    */
    public GentableColumnQuery javaField(String javaField){
        setJavaField(javaField);
		return this;
    }


    /**
    * 设置 JAVA字段名
    * @param javaFieldList
    */
    public GentableColumnQuery javaFieldList(List<String> javaFieldList){
        this.javaFieldList = javaFieldList;
		return this;
    }
	
	/**
    * 设置  是否primaryKey（0否，1 是）
    * @param isPrimaryKey
    */
    public GentableColumnQuery isPrimaryKey(Integer isPrimaryKey){
        setIsPrimaryKey(isPrimaryKey);
		return this;
    }

    /**
    * 设置 开始 是否primaryKey（0否，1 是）
    * @param isPrimaryKeyStart
    */
    public GentableColumnQuery isPrimaryKeyStart(Integer isPrimaryKeyStart){
        this.isPrimaryKeyStart = isPrimaryKeyStart;
		return this;
    }


    /**
    * 设置 结束 是否primaryKey（0否，1 是）
    * @param isPrimaryKeyEnd
    */
    public GentableColumnQuery isPrimaryKeyEnd(Integer isPrimaryKeyEnd){
        this.isPrimaryKeyEnd = isPrimaryKeyEnd;
		return this;
    }


    /**
    * 设置 增加 是否primaryKey（0否，1 是）
    * @param isPrimaryKeyIncrement
    */
    public GentableColumnQuery isPrimaryKeyIncrement(Integer isPrimaryKeyIncrement){
        this.isPrimaryKeyIncrement = isPrimaryKeyIncrement;
		return this;
    }


    /**
    * 设置 是否primaryKey（0否，1 是）
    * @param isPrimaryKeyList
    */
    public GentableColumnQuery isPrimaryKeyList(List<Integer> isPrimaryKeyList){
        this.isPrimaryKeyList = isPrimaryKeyList;
		return this;
    }
	
	/**
    * 设置  是否自增（0否，1 是）
    * @param isIncrement
    */
    public GentableColumnQuery isIncrement(Integer isIncrement){
        setIsIncrement(isIncrement);
		return this;
    }

    /**
    * 设置 开始 是否自增（0否，1 是）
    * @param isIncrementStart
    */
    public GentableColumnQuery isIncrementStart(Integer isIncrementStart){
        this.isIncrementStart = isIncrementStart;
		return this;
    }


    /**
    * 设置 结束 是否自增（0否，1 是）
    * @param isIncrementEnd
    */
    public GentableColumnQuery isIncrementEnd(Integer isIncrementEnd){
        this.isIncrementEnd = isIncrementEnd;
		return this;
    }


    /**
    * 设置 增加 是否自增（0否，1 是）
    * @param isIncrementIncrement
    */
    public GentableColumnQuery isIncrementIncrement(Integer isIncrementIncrement){
        this.isIncrementIncrement = isIncrementIncrement;
		return this;
    }


    /**
    * 设置 是否自增（0否，1 是）
    * @param isIncrementList
    */
    public GentableColumnQuery isIncrementList(List<Integer> isIncrementList){
        this.isIncrementList = isIncrementList;
		return this;
    }
	
	/**
    * 设置  是否必填（0否，1 是）
    * @param isRequired
    */
    public GentableColumnQuery isRequired(Integer isRequired){
        setIsRequired(isRequired);
		return this;
    }

    /**
    * 设置 开始 是否必填（0否，1 是）
    * @param isRequiredStart
    */
    public GentableColumnQuery isRequiredStart(Integer isRequiredStart){
        this.isRequiredStart = isRequiredStart;
		return this;
    }


    /**
    * 设置 结束 是否必填（0否，1 是）
    * @param isRequiredEnd
    */
    public GentableColumnQuery isRequiredEnd(Integer isRequiredEnd){
        this.isRequiredEnd = isRequiredEnd;
		return this;
    }


    /**
    * 设置 增加 是否必填（0否，1 是）
    * @param isRequiredIncrement
    */
    public GentableColumnQuery isRequiredIncrement(Integer isRequiredIncrement){
        this.isRequiredIncrement = isRequiredIncrement;
		return this;
    }


    /**
    * 设置 是否必填（0否，1 是）
    * @param isRequiredList
    */
    public GentableColumnQuery isRequiredList(List<Integer> isRequiredList){
        this.isRequiredList = isRequiredList;
		return this;
    }
	
	/**
    * 设置  是否为插入字段（0否，1 是）
    * @param isInsert
    */
    public GentableColumnQuery isInsert(Integer isInsert){
        setIsInsert(isInsert);
		return this;
    }

    /**
    * 设置 开始 是否为插入字段（0否，1 是）
    * @param isInsertStart
    */
    public GentableColumnQuery isInsertStart(Integer isInsertStart){
        this.isInsertStart = isInsertStart;
		return this;
    }


    /**
    * 设置 结束 是否为插入字段（0否，1 是）
    * @param isInsertEnd
    */
    public GentableColumnQuery isInsertEnd(Integer isInsertEnd){
        this.isInsertEnd = isInsertEnd;
		return this;
    }


    /**
    * 设置 增加 是否为插入字段（0否，1 是）
    * @param isInsertIncrement
    */
    public GentableColumnQuery isInsertIncrement(Integer isInsertIncrement){
        this.isInsertIncrement = isInsertIncrement;
		return this;
    }


    /**
    * 设置 是否为插入字段（0否，1 是）
    * @param isInsertList
    */
    public GentableColumnQuery isInsertList(List<Integer> isInsertList){
        this.isInsertList = isInsertList;
		return this;
    }
	
	/**
    * 设置  是否编辑字段（0否，1 是）
    * @param isEdit
    */
    public GentableColumnQuery isEdit(Integer isEdit){
        setIsEdit(isEdit);
		return this;
    }

    /**
    * 设置 开始 是否编辑字段（0否，1 是）
    * @param isEditStart
    */
    public GentableColumnQuery isEditStart(Integer isEditStart){
        this.isEditStart = isEditStart;
		return this;
    }


    /**
    * 设置 结束 是否编辑字段（0否，1 是）
    * @param isEditEnd
    */
    public GentableColumnQuery isEditEnd(Integer isEditEnd){
        this.isEditEnd = isEditEnd;
		return this;
    }


    /**
    * 设置 增加 是否编辑字段（0否，1 是）
    * @param isEditIncrement
    */
    public GentableColumnQuery isEditIncrement(Integer isEditIncrement){
        this.isEditIncrement = isEditIncrement;
		return this;
    }


    /**
    * 设置 是否编辑字段（0否，1 是）
    * @param isEditList
    */
    public GentableColumnQuery isEditList(List<Integer> isEditList){
        this.isEditList = isEditList;
		return this;
    }
	
	/**
    * 设置  是否列表字段（0否，1 是）
    * @param isList
    */
    public GentableColumnQuery isList(Integer isList){
        setIsList(isList);
		return this;
    }

    /**
    * 设置 开始 是否列表字段（0否，1 是）
    * @param isListStart
    */
    public GentableColumnQuery isListStart(Integer isListStart){
        this.isListStart = isListStart;
		return this;
    }


    /**
    * 设置 结束 是否列表字段（0否，1 是）
    * @param isListEnd
    */
    public GentableColumnQuery isListEnd(Integer isListEnd){
        this.isListEnd = isListEnd;
		return this;
    }


    /**
    * 设置 增加 是否列表字段（0否，1 是）
    * @param isListIncrement
    */
    public GentableColumnQuery isListIncrement(Integer isListIncrement){
        this.isListIncrement = isListIncrement;
		return this;
    }


    /**
    * 设置 是否列表字段（0否，1 是）
    * @param isListList
    */
    public GentableColumnQuery isListList(List<Integer> isListList){
        this.isListList = isListList;
		return this;
    }
	
	/**
    * 设置  是否查询字段（0否，1 是）
    * @param isQuery
    */
    public GentableColumnQuery isQuery(Integer isQuery){
        setIsQuery(isQuery);
		return this;
    }

    /**
    * 设置 开始 是否查询字段（0否，1 是）
    * @param isQueryStart
    */
    public GentableColumnQuery isQueryStart(Integer isQueryStart){
        this.isQueryStart = isQueryStart;
		return this;
    }


    /**
    * 设置 结束 是否查询字段（0否，1 是）
    * @param isQueryEnd
    */
    public GentableColumnQuery isQueryEnd(Integer isQueryEnd){
        this.isQueryEnd = isQueryEnd;
		return this;
    }


    /**
    * 设置 增加 是否查询字段（0否，1 是）
    * @param isQueryIncrement
    */
    public GentableColumnQuery isQueryIncrement(Integer isQueryIncrement){
        this.isQueryIncrement = isQueryIncrement;
		return this;
    }


    /**
    * 设置 是否查询字段（0否，1 是）
    * @param isQueryList
    */
    public GentableColumnQuery isQueryList(List<Integer> isQueryList){
        this.isQueryList = isQueryList;
		return this;
    }
	
	/**
    * 设置  显示类型（1.文本框、2.文本域、3.下拉框、4.复选框、5.单选框、6.日期控件）
    * @param htmlType
    */
    public GentableColumnQuery htmlType(Integer htmlType){
        setHtmlType(htmlType);
		return this;
    }

    /**
    * 设置 开始 显示类型（1.文本框、2.文本域、3.下拉框、4.复选框、5.单选框、6.日期控件）
    * @param htmlTypeStart
    */
    public GentableColumnQuery htmlTypeStart(Integer htmlTypeStart){
        this.htmlTypeStart = htmlTypeStart;
		return this;
    }


    /**
    * 设置 结束 显示类型（1.文本框、2.文本域、3.下拉框、4.复选框、5.单选框、6.日期控件）
    * @param htmlTypeEnd
    */
    public GentableColumnQuery htmlTypeEnd(Integer htmlTypeEnd){
        this.htmlTypeEnd = htmlTypeEnd;
		return this;
    }


    /**
    * 设置 增加 显示类型（1.文本框、2.文本域、3.下拉框、4.复选框、5.单选框、6.日期控件）
    * @param htmlTypeIncrement
    */
    public GentableColumnQuery htmlTypeIncrement(Integer htmlTypeIncrement){
        this.htmlTypeIncrement = htmlTypeIncrement;
		return this;
    }


    /**
    * 设置 显示类型（1.文本框、2.文本域、3.下拉框、4.复选框、5.单选框、6.日期控件）
    * @param htmlTypeList
    */
    public GentableColumnQuery htmlTypeList(List<Integer> htmlTypeList){
        this.htmlTypeList = htmlTypeList;
		return this;
    }
	
	/**
    * 设置  排序
    * @param sort
    */
    public GentableColumnQuery sort(Integer sort){
        setSort(sort);
		return this;
    }

    /**
    * 设置 开始 排序
    * @param sortStart
    */
    public GentableColumnQuery sortStart(Integer sortStart){
        this.sortStart = sortStart;
		return this;
    }


    /**
    * 设置 结束 排序
    * @param sortEnd
    */
    public GentableColumnQuery sortEnd(Integer sortEnd){
        this.sortEnd = sortEnd;
		return this;
    }


    /**
    * 设置 增加 排序
    * @param sortIncrement
    */
    public GentableColumnQuery sortIncrement(Integer sortIncrement){
        this.sortIncrement = sortIncrement;
		return this;
    }


    /**
    * 设置 排序
    * @param sortList
    */
    public GentableColumnQuery sortList(List<Integer> sortList){
        this.sortList = sortList;
		return this;
    }

    /**
    * 设置 开始 变更时间
    * @param updateTimeStart
    */
    public GentableColumnQuery updateTimeStart(String updateTimeStart){
		this.updateTimeStart = updateTimeStart;
		return this;
    }


    /**
    * 设置 结束 变更时间
    * @param updateTimeEnd
    */
    public GentableColumnQuery updateTimeEnd(String updateTimeEnd){
		this.updateTimeEnd = updateTimeEnd;
		return this;
    }
	/**
    * 设置 变更用户loginName
    * @param updateUser
    */
    public GentableColumnQuery updateUser(String updateUser){
        setUpdateUser(updateUser);
		return this;
    }


    /**
    * 设置 变更用户loginName
    * @param updateUserList
    */
    public GentableColumnQuery updateUserList(List<String> updateUserList){
        this.updateUserList = updateUserList;
		return this;
    }

    /**
    * 设置 开始 创建时间
    * @param createTimeStart
    */
    public GentableColumnQuery createTimeStart(String createTimeStart){
		this.createTimeStart = createTimeStart;
		return this;
    }


    /**
    * 设置 结束 创建时间
    * @param createTimeEnd
    */
    public GentableColumnQuery createTimeEnd(String createTimeEnd){
		this.createTimeEnd = createTimeEnd;
		return this;
    }
	/**
    * 设置 创建用户loginName
    * @param createUser
    */
    public GentableColumnQuery createUser(String createUser){
        setCreateUser(createUser);
		return this;
    }


    /**
    * 设置 创建用户loginName
    * @param createUserList
    */
    public GentableColumnQuery createUserList(List<String> createUserList){
        this.createUserList = createUserList;
		return this;
    }


    /**
    * 获取 OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
    * @return orConditionList
    */
    public List<GentableColumnQuery> getOrConditionList(){
    return this.orConditionList;
    }

    /**
    * 设置 OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
    * @param orConditionList
    */
    public void setOrConditionList(List<GentableColumnQuery> orConditionList){
        this.orConditionList = orConditionList;
    }

    /**
    * 获取 AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4)
    * @return andConditionList
    */
    public List<GentableColumnQuery> getAndConditionList(){
        return this.andConditionList;
    }

    /**
    * 设置 AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4)
    * @param andConditionList
    */
    public void setAndConditionList(List<GentableColumnQuery> andConditionList){
        this.andConditionList = andConditionList;
    }

}