Merge remote-tracking branch 'origin/dev' into dev

dev^2
zhoushen 1 year ago
commit a656ab6bcc

@ -1,2 +0,0 @@
# MyBatis generate files #
src\main\resources\com\macro\mall\mapper

@ -1,90 +0,0 @@
package com.macro.mall.mapper;
import com.macro.mall.model.CmsHelpCategory;
import com.macro.mall.model.CmsHelpCategoryExample;
import java.util.List;
import org.apache.ibatis.annotations.Param;
/**
* CmsHelpCategoryMapper CmsHelpCategory
*/
public interface CmsHelpCategoryMapper {
/**
*
* @param example
* @return
*/
long countByExample(CmsHelpCategoryExample example);
/**
*
* @param example
* @return
*/
int deleteByExample(CmsHelpCategoryExample example);
/**
*
* @param id ID
* @return
*/
int deleteByPrimaryKey(Long id);
/**
*
* @param record
* @return
*/
int insert(CmsHelpCategory record);
/**
* null
* @param record
* @return
*/
int insertSelective(CmsHelpCategory record);
/**
*
* @param example
* @return
*/
List<CmsHelpCategory> selectByExample(CmsHelpCategoryExample example);
/**
*
* @param id ID
* @return
*/
CmsHelpCategory selectByPrimaryKey(Long id);
/**
* null
* @param record
* @param example
* @return
*/
int updateByExampleSelective(@Param("record") CmsHelpCategory record, @Param("example") CmsHelpCategoryExample example);
/**
*
* @param record
* @param example
* @return
*/
int updateByExample(@Param("record") CmsHelpCategory record, @Param("example") CmsHelpCategoryExample example);
/**
* null
* @param record
* @return
*/
int updateByPrimaryKeySelective(CmsHelpCategory record);
/**
*
* @param record
* @return
*/
int updateByPrimaryKey(CmsHelpCategory record);
}

@ -1,112 +0,0 @@
package com.macro.mall.mapper;
import com.macro.mall.model.CmsHelp;
import com.macro.mall.model.CmsHelpExample;
import java.util.List;
import org.apache.ibatis.annotations.Param;
/**
* CmsHelpMapper CmsHelp
*/
public interface CmsHelpMapper {
/**
*
* @param example
* @return
*/
long countByExample(CmsHelpExample example);
/**
*
* @param example
* @return
*/
int deleteByExample(CmsHelpExample example);
/**
*
* @param id ID
* @return
*/
int deleteByPrimaryKey(Long id);
/**
*
* @param record
* @return
*/
int insert(CmsHelp record);
/**
* null
* @param record
* @return
*/
int insertSelective(CmsHelp record);
/**
* BLOB
* @param example
* @return BLOB
*/
List<CmsHelp> selectByExampleWithBLOBs(CmsHelpExample example);
/**
* BLOB
* @param example
* @return BLOB
*/
List<CmsHelp> selectByExample(CmsHelpExample example);
/**
*
* @param id ID
* @return
*/
CmsHelp selectByPrimaryKey(Long id);
/**
* null
* @param record
* @param example
* @return
*/
int updateByExampleSelective(@Param("record") CmsHelp record, @Param("example") CmsHelpExample example);
/**
* BLOB
* @param record
* @param example
* @return
*/
int updateByExampleWithBLOBs(@Param("record") CmsHelp record, @Param("example") CmsHelpExample example);
/**
*
* @param record
* @param example
* @return
*/
int updateByExample(@Param("record") CmsHelp record, @Param("example") CmsHelpExample example);
/**
* null
* @param record
* @return
*/
int updateByPrimaryKeySelective(CmsHelp record);
/**
* BLOB
* @param record
* @return
*/
int updateByPrimaryKeyWithBLOBs(CmsHelp record);
/**
*
* @param record
* @return
*/
int updateByPrimaryKey(CmsHelp record);
}

@ -1,62 +0,0 @@
package com.macro.mall.mapper;
import com.macro.mall.model.CmsMemberReport;
import com.macro.mall.model.CmsMemberReportExample;
import java.util.List;
import org.apache.ibatis.annotations.Param;
/**
* CmsMemberReportMapper CmsMemberReport
*/
public interface CmsMemberReportMapper {
/**
*
* @param example
* @return
*/
long countByExample(CmsMemberReportExample example);
/**
*
* @param example
* @return
*/
int deleteByExample(CmsMemberReportExample example);
/**
*
* @param record
* @return
*/
int insert(CmsMemberReport record);
/**
* null
* @param record
* @return
*/
int insertSelective(CmsMemberReport record);
/**
*
* @param example
* @return
*/
List<CmsMemberReport> selectByExample(CmsMemberReportExample example);
/**
* null
* @param record
* @param example
* @return
*/
int updateByExampleSelective(@Param("record") CmsMemberReport record, @Param("example") CmsMemberReportExample example);
/**
*
* @param record
* @param example
* @return
*/
int updateByExample(@Param("record") CmsMemberReport record, @Param("example") CmsMemberReportExample example);
}

@ -1,112 +0,0 @@
package com.macro.mall.mapper;
import com.macro.mall.model.CmsPrefrenceArea;
import com.macro.mall.model.CmsPrefrenceAreaExample;
import java.util.List;
import org.apache.ibatis.annotations.Param;
/**
* CmsPrefrenceAreaMapper CmsPrefrenceArea
*/
public interface CmsPrefrenceAreaMapper {
/**
*
* @param example
* @return
*/
long countByExample(CmsPrefrenceAreaExample example);
/**
*
* @param example
* @return
*/
int deleteByExample(CmsPrefrenceAreaExample example);
/**
*
* @param id ID
* @return
*/
int deleteByPrimaryKey(Long id);
/**
*
* @param record
* @return
*/
int insert(CmsPrefrenceArea record);
/**
* null
* @param record
* @return
*/
int insertSelective(CmsPrefrenceArea record);
/**
* BLOB
* @param example
* @return BLOB
*/
List<CmsPrefrenceArea> selectByExampleWithBLOBs(CmsPrefrenceAreaExample example);
/**
* BLOB
* @param example
* @return BLOB
*/
List<CmsPrefrenceArea> selectByExample(CmsPrefrenceAreaExample example);
/**
*
* @param id ID
* @return
*/
CmsPrefrenceArea selectByPrimaryKey(Long id);
/**
* null
* @param record
* @param example
* @return
*/
int updateByExampleSelective(@Param("record") CmsPrefrenceArea record, @Param("example") CmsPrefrenceAreaExample example);
/**
* BLOB
* @param record
* @param example
* @return
*/
int updateByExampleWithBLOBs(@Param("record") CmsPrefrenceArea record, @Param("example") CmsPrefrenceAreaExample example);
/**
*
* @param record
* @param example
* @return
*/
int updateByExample(@Param("record") CmsPrefrenceArea record, @Param("example") CmsPrefrenceAreaExample example);
/**
* null
* @param record
* @return
*/
int updateByPrimaryKeySelective(CmsPrefrenceArea record);
/**
* BLOB
* @param record
* @return
*/
int updateByPrimaryKeyWithBLOBs(CmsPrefrenceArea record);
/**
*
* @param record
* @return
*/
int updateByPrimaryKey(CmsPrefrenceArea record);
}

@ -1,32 +0,0 @@
package com.macro.mall.mapper; // 定义了该接口所属的包名用于Java的包管理
import com.macro.mall.model.CmsPrefrenceAreaProductRelation; // 导入了实体类,用于数据库表的映射
import com.macro.mall.model.CmsPrefrenceAreaProductRelationExample; // 导入了实体类的Example类用于构建查询条件
import java.util.List; // 导入了List接口用于存储查询结果集
import org.apache.ibatis.annotations.Param; // 导入了MyBatis的Param注解用于指定参数名称
public interface CmsPrefrenceAreaProductRelationMapper { // 声明了一个MyBatis的Mapper接口
// 以下方法都是MyBatis映射的方法用于数据库的CRUD操作
long countByExample(CmsPrefrenceAreaProductRelationExample example); // 根据example条件统计记录数
int deleteByExample(CmsPrefrenceAreaProductRelationExample example); // 根据example条件删除记录
int deleteByPrimaryKey(Long id); // 根据主键删除记录
int insert(CmsPrefrenceAreaProductRelation record); // 插入一条记录
int insertSelective(CmsPrefrenceAreaProductRelation record); // 插入一条记录只插入不为null的字段
List<CmsPrefrenceAreaProductRelation> selectByExample(CmsPrefrenceAreaProductRelationExample example); // 根据example条件查询记录
CmsPrefrenceAreaProductRelation selectByPrimaryKey(Long id); // 根据主键查询记录
int updateByExampleSelective(@Param("record") CmsPrefrenceAreaProductRelation record, @Param("example") CmsPrefrenceAreaProductRelationExample example); // 根据example条件更新记录只更新不为null的字段
int updateByExample(@Param("record") CmsPrefrenceAreaProductRelation record, @Param("example") CmsPrefrenceAreaProductRelationExample example); // 根据example条件更新记录
int updateByPrimaryKeySelective(CmsPrefrenceAreaProductRelation record); // 根据主键更新记录只更新不为null的字段
int updateByPrimaryKey(CmsPrefrenceAreaProductRelation record); // 根据主键更新记录
}

@ -1,32 +0,0 @@
package com.macro.mall.mapper; // 定义了该接口所属的包名用于Java的包管理
import com.macro.mall.model.CmsSubjectCategory; // 导入了CmsSubjectCategory实体类用于数据库表的映射
import com.macro.mall.model.CmsSubjectCategoryExample; // 导入了CmsSubjectCategoryExample类用于构建查询条件
import java.util.List; // 导入了List接口用于存储查询结果集
import org.apache.ibatis.annotations.Param; // 导入了MyBatis的Param注解用于指定参数名称
public interface CmsSubjectCategoryMapper { // 声明了一个MyBatis的Mapper接口用于数据库操作
// 以下方法都是MyBatis映射的方法用于数据库的CRUD操作
long countByExample(CmsSubjectCategoryExample example); // 根据example条件统计记录数
int deleteByExample(CmsSubjectCategoryExample example); // 根据example条件删除记录
int deleteByPrimaryKey(Long id); // 根据主键id删除记录
int insert(CmsSubjectCategory record); // 插入一条CmsSubjectCategory记录
int insertSelective(CmsSubjectCategory record); // 插入一条CmsSubjectCategory记录只插入不为null的字段
List<CmsSubjectCategory> selectByExample(CmsSubjectCategoryExample example); // 根据example条件查询CmsSubjectCategory记录
CmsSubjectCategory selectByPrimaryKey(Long id); // 根据主键id查询CmsSubjectCategory记录
int updateByExampleSelective(@Param("record") CmsSubjectCategory record, @Param("example") CmsSubjectCategoryExample example); // 根据example条件更新CmsSubjectCategory记录只更新不为null的字段
int updateByExample(@Param("record") CmsSubjectCategory record, @Param("example") CmsSubjectCategoryExample example); // 根据example条件更新CmsSubjectCategory记录
int updateByPrimaryKeySelective(CmsSubjectCategory record); // 根据主键id更新CmsSubjectCategory记录只更新不为null的字段
int updateByPrimaryKey(CmsSubjectCategory record); // 根据主键id更新CmsSubjectCategory记录
}

@ -1,32 +0,0 @@
package com.macro.mall.mapper; // 定义了该接口所属的包名用于Java的包管理
import com.macro.mall.model.CmsSubjectComment; // 导入了CmsSubjectComment实体类用于数据库表的映射
import com.macro.mall.model.CmsSubjectCommentExample; // 导入了CmsSubjectCommentExample类用于构建查询条件
import java.util.List; // 导入了List接口用于存储查询结果集
import org.apache.ibatis.annotations.Param; // 导入了MyBatis的Param注解用于指定参数名称
public interface CmsSubjectCommentMapper { // 声明了一个MyBatis的Mapper接口用于数据库操作
// 以下方法都是MyBatis映射的方法用于数据库的CRUD操作
long countByExample(CmsSubjectCommentExample example); // 根据example条件统计记录数
int deleteByExample(CmsSubjectCommentExample example); // 根据example条件删除记录
int deleteByPrimaryKey(Long id); // 根据主键id删除记录
int insert(CmsSubjectComment record); // 插入一条CmsSubjectComment记录
int insertSelective(CmsSubjectComment record); // 插入一条CmsSubjectComment记录只插入不为null的字段
List<CmsSubjectComment> selectByExample(CmsSubjectCommentExample example); // 根据example条件查询CmsSubjectComment记录
CmsSubjectComment selectByPrimaryKey(Long id); // 根据主键id查询CmsSubjectComment记录
int updateByExampleSelective(@Param("record") CmsSubjectComment record, @Param("example") CmsSubjectCommentExample example); // 根据example条件更新CmsSubjectComment记录只更新不为null的字段
int updateByExample(@Param("record") CmsSubjectComment record, @Param("example") CmsSubjectCommentExample example); // 根据example条件更新CmsSubjectComment记录
int updateByPrimaryKeySelective(CmsSubjectComment record); // 根据主键id更新CmsSubjectComment记录只更新不为null的字段
int updateByPrimaryKey(CmsSubjectComment record); // 根据主键id更新CmsSubjectComment记录
}

@ -1,38 +0,0 @@
package com.macro.mall.mapper; // 定义了该接口所属的包名用于Java的包管理
import com.macro.mall.model.CmsSubject; // 导入了CmsSubject实体类用于数据库表的映射
import com.macro.mall.model.CmsSubjectExample; // 导入了CmsSubjectExample类用于构建查询条件
import java.util.List; // 导入了List接口用于存储查询结果集
import org.apache.ibatis.annotations.Param; // 导入了MyBatis的Param注解用于指定参数名称
public interface CmsSubjectMapper { // 声明了一个MyBatis的Mapper接口用于数据库操作
// 以下方法都是MyBatis映射的方法用于数据库的CRUD操作
long countByExample(CmsSubjectExample example); // 根据example条件统计记录数
int deleteByExample(CmsSubjectExample example); // 根据example条件删除记录
int deleteByPrimaryKey(Long id); // 根据主键id删除记录
int insert(CmsSubject record); // 插入一条CmsSubject记录
int insertSelective(CmsSubject record); // 插入一条CmsSubject记录只插入不为null的字段
List<CmsSubject> selectByExampleWithBLOBs(CmsSubjectExample example); // 根据example条件查询CmsSubject记录包括BLOB字段
List<CmsSubject> selectByExample(CmsSubjectExample example); // 根据example条件查询CmsSubject记录不包括BLOB字段
CmsSubject selectByPrimaryKey(Long id); // 根据主键id查询CmsSubject记录
int updateByExampleSelective(@Param("record") CmsSubject record, @Param("example") CmsSubjectExample example); // 根据example条件更新CmsSubject记录只更新不为null的字段
int updateByExampleWithBLOBs(@Param("record") CmsSubject record, @Param("example") CmsSubjectExample example); // 根据example条件更新CmsSubject记录包括BLOB字段
int updateByExample(@Param("record") CmsSubject record, @Param("example") CmsSubjectExample example); // 根据example条件更新CmsSubject记录
int updateByPrimaryKeySelective(CmsSubject record); // 根据主键id更新CmsSubject记录只更新不为null的字段
int updateByPrimaryKeyWithBLOBs(CmsSubject record); // 根据主键id更新CmsSubject记录包括BLOB字段
int updateByPrimaryKey(CmsSubject record); // 根据主键id更新CmsSubject记录
}

@ -1,32 +0,0 @@
package com.macro.mall.mapper; // 定义了该接口所属的包名用于Java的包管理
import com.macro.mall.model.CmsSubjectProductRelation; // 导入了CmsSubjectProductRelation实体类用于数据库表的映射
import com.macro.mall.model.CmsSubjectProductRelationExample; // 导入了CmsSubjectProductRelationExample类用于构建查询条件
import java.util.List; // 导入了List接口用于存储查询结果集
import org.apache.ibatis.annotations.Param; // 导入了MyBatis的Param注解用于指定参数名称
public interface CmsSubjectProductRelationMapper { // 声明了一个MyBatis的Mapper接口用于数据库操作
// 以下方法都是MyBatis映射的方法用于数据库的CRUD操作
long countByExample(CmsSubjectProductRelationExample example); // 根据example条件统计记录数
int deleteByExample(CmsSubjectProductRelationExample example); // 根据example条件删除记录
int deleteByPrimaryKey(Long id); // 根据主键id删除记录
int insert(CmsSubjectProductRelation record); // 插入一条CmsSubjectProductRelation记录
int insertSelective(CmsSubjectProductRelation record); // 插入一条CmsSubjectProductRelation记录只插入不为null的字段
List<CmsSubjectProductRelation> selectByExample(CmsSubjectProductRelationExample example); // 根据example条件查询CmsSubjectProductRelation记录
CmsSubjectProductRelation selectByPrimaryKey(Long id); // 根据主键id查询CmsSubjectProductRelation记录
int updateByExampleSelective(@Param("record") CmsSubjectProductRelation record, @Param("example") CmsSubjectProductRelationExample example); // 根据example条件更新CmsSubjectProductRelation记录只更新不为null的字段
int updateByExample(@Param("record") CmsSubjectProductRelation record, @Param("example") CmsSubjectProductRelationExample example); // 根据example条件更新CmsSubjectProductRelation记录
int updateByPrimaryKeySelective(CmsSubjectProductRelation record); // 根据主键id更新CmsSubjectProductRelation记录只更新不为null的字段
int updateByPrimaryKey(CmsSubjectProductRelation record); // 根据主键id更新CmsSubjectProductRelation记录
}

@ -1,32 +0,0 @@
package com.macro.mall.mapper; // 定义了该接口所属的包名用于Java的包管理
import com.macro.mall.model.CmsTopicCategory; // 导入了CmsTopicCategory实体类用于数据库表的映射
import com.macro.mall.model.CmsTopicCategoryExample; // 导入了CmsTopicCategoryExample类用于构建查询条件
import java.util.List; // 导入了List接口用于存储查询结果集
import org.apache.ibatis.annotations.Param; // 导入了MyBatis的Param注解用于指定参数名称
public interface CmsTopicCategoryMapper { // 声明了一个MyBatis的Mapper接口用于数据库操作
// 以下方法都是MyBatis映射的方法用于数据库的CRUD操作
long countByExample(CmsTopicCategoryExample example); // 根据example条件统计记录数
int deleteByExample(CmsTopicCategoryExample example); // 根据example条件删除记录
int deleteByPrimaryKey(Long id); // 根据主键id删除记录
int insert(CmsTopicCategory record); // 插入一条CmsTopicCategory记录
int insertSelective(CmsTopicCategory record); // 插入一条CmsTopicCategory记录只插入不为null的字段
List<CmsTopicCategory> selectByExample(CmsTopicCategoryExample example); // 根据example条件查询CmsTopicCategory记录
CmsTopicCategory selectByPrimaryKey(Long id); // 根据主键id查询CmsTopicCategory记录
int updateByExampleSelective(@Param("record") CmsTopicCategory record, @Param("example") CmsTopicCategoryExample example); // 根据example条件更新CmsTopicCategory记录只更新不为null的字段
int updateByExample(@Param("record") CmsTopicCategory record, @Param("example") CmsTopicCategoryExample example); // 根据example条件更新CmsTopicCategory记录
int updateByPrimaryKeySelective(CmsTopicCategory record); // 根据主键id更新CmsTopicCategory记录只更新不为null的字段
int updateByPrimaryKey(CmsTopicCategory record); // 根据主键id更新CmsTopicCategory记录
}

@ -1,32 +0,0 @@
package com.macro.mall.mapper; // 定义了该接口所属的包名用于Java的包管理
import com.macro.mall.model.CmsTopicComment; // 导入了CmsTopicComment实体类用于数据库表的映射
import com.macro.mall.model.CmsTopicCommentExample; // 导入了CmsTopicCommentExample类用于构建查询条件
import java.util.List; // 导入了List接口用于存储查询结果集
import org.apache.ibatis.annotations.Param; // 导入了MyBatis的Param注解用于指定参数名称
public interface CmsTopicCommentMapper { // 声明了一个MyBatis的Mapper接口用于数据库操作
// 以下方法都是MyBatis映射的方法用于数据库的CRUD操作
long countByExample(CmsTopicCommentExample example); // 根据example条件统计记录数
int deleteByExample(CmsTopicCommentExample example); // 根据example条件删除记录
int deleteByPrimaryKey(Long id); // 根据主键id删除记录
int insert(CmsTopicComment record); // 插入一条CmsTopicComment记录
int insertSelective(CmsTopicComment record); // 插入一条CmsTopicComment记录只插入不为null的字段
List<CmsTopicComment> selectByExample(CmsTopicCommentExample example); // 根据example条件查询CmsTopicComment记录
CmsTopicComment selectByPrimaryKey(Long id); // 根据主键id查询CmsTopicComment记录
int updateByExampleSelective(@Param("record") CmsTopicComment record, @Param("example") CmsTopicCommentExample example); // 根据example条件更新CmsTopicComment记录只更新不为null的字段
int updateByExample(@Param("record") CmsTopicComment record, @Param("example") CmsTopicCommentExample example); // 根据example条件更新CmsTopicComment记录
int updateByPrimaryKeySelective(CmsTopicComment record); // 根据主键id更新CmsTopicComment记录只更新不为null的字段
int updateByPrimaryKey(CmsTopicComment record); // 根据主键id更新CmsTopicComment记录
}

@ -1,38 +0,0 @@
package com.macro.mall.mapper; // 定义了该接口所属的包名用于Java的包管理
import com.macro.mall.model.CmsTopic; // 导入了CmsTopic实体类用于数据库表的映射
import com.macro.mall.model.CmsTopicExample; // 导入了CmsTopicExample类用于构建查询条件
import java.util.List; // 导入了List接口用于存储查询结果集
import org.apache.ibatis.annotations.Param; // 导入了MyBatis的Param注解用于指定参数名称
public interface CmsTopicMapper { // 声明了一个MyBatis的Mapper接口用于数据库操作
// 以下方法都是MyBatis映射的方法用于数据库的CRUD操作
long countByExample(CmsTopicExample example); // 根据example条件统计记录数
int deleteByExample(CmsTopicExample example); // 根据example条件删除记录
int deleteByPrimaryKey(Long id); // 根据主键id删除记录
int insert(CmsTopic record); // 插入一条CmsTopic记录
int insertSelective(CmsTopic record); // 插入一条CmsTopic记录只插入不为null的字段
List<CmsTopic> selectByExampleWithBLOBs(CmsTopicExample example); // 根据example条件查询CmsTopic记录包括BLOB字段
List<CmsTopic> selectByExample(CmsTopicExample example); // 根据example条件查询CmsTopic记录不包括BLOB字段
CmsTopic selectByPrimaryKey(Long id); // 根据主键id查询CmsTopic记录
int updateByExampleSelective(@Param("record") CmsTopic record, @Param("example") CmsTopicExample example); // 根据example条件更新CmsTopic记录只更新不为null的字段
int updateByExampleWithBLOBs(@Param("record") CmsTopic record, @Param("example") CmsTopicExample example); // 根据example条件更新CmsTopic记录包括BLOB字段
int updateByExample(@Param("record") CmsTopic record, @Param("example") CmsTopicExample example); // 根据example条件更新CmsTopic记录
int updateByPrimaryKeySelective(CmsTopic record); // 根据主键id更新CmsTopic记录只更新不为null的字段
int updateByPrimaryKeyWithBLOBs(CmsTopic record); // 根据主键id更新CmsTopic记录包括BLOB字段
int updateByPrimaryKey(CmsTopic record); // 根据主键id更新CmsTopic记录
}

@ -1,32 +0,0 @@
package com.macro.mall.mapper; // 定义了该接口所属的包名用于Java的包管理
import com.macro.mall.model.OmsCartItem; // 导入了OmsCartItem实体类用于数据库表的映射
import com.macro.mall.model.OmsCartItemExample; // 导入了OmsCartItemExample类用于构建查询条件
import java.util.List; // 导入了List接口用于存储查询结果集
import org.apache.ibatis.annotations.Param; // 导入了MyBatis的Param注解用于指定参数名称
public interface OmsCartItemMapper { // 声明了一个MyBatis的Mapper接口用于数据库操作
// 以下方法都是MyBatis映射的方法用于数据库的CRUD操作
long countByExample(OmsCartItemExample example); // 根据example条件统计记录数
int deleteByExample(OmsCartItemExample example); // 根据example条件删除记录
int deleteByPrimaryKey(Long id); // 根据主键id删除记录
int insert(OmsCartItem record); // 插入一条OmsCartItem记录
int insertSelective(OmsCartItem record); // 插入一条OmsCartItem记录只插入不为null的字段
List<OmsCartItem> selectByExample(OmsCartItemExample example); // 根据example条件查询OmsCartItem记录
OmsCartItem selectByPrimaryKey(Long id); // 根据主键id查询OmsCartItem记录
int updateByExampleSelective(@Param("record") OmsCartItem record, @Param("example") OmsCartItemExample example); // 根据example条件更新OmsCartItem记录只更新不为null的字段
int updateByExample(@Param("record") OmsCartItem record, @Param("example") OmsCartItemExample example); // 根据example条件更新OmsCartItem记录
int updateByPrimaryKeySelective(OmsCartItem record); // 根据主键id更新OmsCartItem记录只更新不为null的字段
int updateByPrimaryKey(OmsCartItem record); // 根据主键id更新OmsCartItem记录
}

@ -1,32 +0,0 @@
package com.macro.mall.mapper; // 定义了该接口所属的包名用于Java的包管理
import com.macro.mall.model.OmsCompanyAddress; // 导入了OmsCompanyAddress实体类用于数据库表的映射
import com.macro.mall.model.OmsCompanyAddressExample; // 导入了OmsCompanyAddressExample类用于构建查询条件
import java.util.List; // 导入了List接口用于存储查询结果集
import org.apache.ibatis.annotations.Param; // 导入了MyBatis的Param注解用于指定参数名称
public interface OmsCompanyAddressMapper { // 声明了一个MyBatis的Mapper接口用于数据库操作
// 以下方法都是MyBatis映射的方法用于数据库的CRUD操作
long countByExample(OmsCompanyAddressExample example); // 根据example条件统计记录数
int deleteByExample(OmsCompanyAddressExample example); // 根据example条件删除记录
int deleteByPrimaryKey(Long id); // 根据主键id删除记录
int insert(OmsCompanyAddress record); // 插入一条OmsCompanyAddress记录
int insertSelective(OmsCompanyAddress record); // 插入一条OmsCompanyAddress记录只插入不为null的字段
List<OmsCompanyAddress> selectByExample(OmsCompanyAddressExample example); // 根据example条件查询OmsCompanyAddress记录
OmsCompanyAddress selectByPrimaryKey(Long id); // 根据主键id查询OmsCompanyAddress记录
int updateByExampleSelective(@Param("record") OmsCompanyAddress record, @Param("example") OmsCompanyAddressExample example); // 根据example条件更新OmsCompanyAddress记录只更新不为null的字段
int updateByExample(@Param("record") OmsCompanyAddress record, @Param("example") OmsCompanyAddressExample example); // 根据example条件更新OmsCompanyAddress记录
int updateByPrimaryKeySelective(OmsCompanyAddress record); // 根据主键id更新OmsCompanyAddress记录只更新不为null的字段
int updateByPrimaryKey(OmsCompanyAddress record); // 根据主键id更新OmsCompanyAddress记录
}

@ -1,32 +0,0 @@
package com.macro.mall.mapper; // 定义了该接口所属的包名用于Java的包管理
import com.macro.mall.model.OmsOrderItem; // 导入了OmsOrderItem实体类用于数据库表的映射
import com.macro.mall.model.OmsOrderItemExample; // 导入了OmsOrderItemExample类用于构建查询条件
import java.util.List; // 导入了List接口用于存储查询结果集
import org.apache.ibatis.annotations.Param; // 导入了MyBatis的Param注解用于指定参数名称
public interface OmsOrderItemMapper { // 声明了一个MyBatis的Mapper接口用于数据库操作
// 以下方法都是MyBatis映射的方法用于数据库的CRUD操作
long countByExample(OmsOrderItemExample example); // 根据example条件统计记录数
int deleteByExample(OmsOrderItemExample example); // 根据example条件删除记录
int deleteByPrimaryKey(Long id); // 根据主键id删除记录
int insert(OmsOrderItem record); // 插入一条OmsOrderItem记录
int insertSelective(OmsOrderItem record); // 插入一条OmsOrderItem记录只插入不为null的字段
List<OmsOrderItem> selectByExample(OmsOrderItemExample example); // 根据example条件查询OmsOrderItem记录
OmsOrderItem selectByPrimaryKey(Long id); // 根据主键id查询OmsOrderItem记录
int updateByExampleSelective(@Param("record") OmsOrderItem record, @Param("example") OmsOrderItemExample example); // 根据example条件更新OmsOrderItem记录只更新不为null的字段
int updateByExample(@Param("record") OmsOrderItem record, @Param("example") OmsOrderItemExample example); // 根据example条件更新OmsOrderItem记录
int updateByPrimaryKeySelective(OmsOrderItem record); // 根据主键id更新OmsOrderItem记录只更新不为null的字段
int updateByPrimaryKey(OmsOrderItem record); // 根据主键id更新OmsOrderItem记录
}

@ -1,32 +0,0 @@
package com.macro.mall.mapper; // 定义了该接口所属的包名用于Java的包管理
import com.macro.mall.model.OmsOrder; // 导入了OmsOrder实体类用于数据库表的映射
import com.macro.mall.model.OmsOrderExample; // 导入了OmsOrderExample类用于构建查询条件
import java.util.List; // 导入了List接口用于存储查询结果集
import org.apache.ibatis.annotations.Param; // 导入了MyBatis的Param注解用于指定参数名称
public interface OmsOrderMapper { // 声明了一个MyBatis的Mapper接口用于数据库操作
// 以下方法都是MyBatis映射的方法用于数据库的CRUD操作
long countByExample(OmsOrderExample example); // 根据example条件统计记录数
int deleteByExample(OmsOrderExample example); // 根据example条件删除记录
int deleteByPrimaryKey(Long id); // 根据主键id删除记录
int insert(OmsOrder record); // 插入一条OmsOrder记录
int insertSelective(OmsOrder record); // 插入一条OmsOrder记录只插入不为null的字段
List<OmsOrder> selectByExample(OmsOrderExample example); // 根据example条件查询OmsOrder记录
OmsOrder selectByPrimaryKey(Long id); // 根据主键id查询OmsOrder记录
int updateByExampleSelective(@Param("record") OmsOrder record, @Param("example") OmsOrderExample example); // 根据example条件更新OmsOrder记录只更新不为null的字段
int updateByExample(@Param("record") OmsOrder record, @Param("example") OmsOrderExample example); // 根据example条件更新OmsOrder记录
int updateByPrimaryKeySelective(OmsOrder record); // 根据主键id更新OmsOrder记录只更新不为null的字段
int updateByPrimaryKey(OmsOrder record); // 根据主键id更新OmsOrder记录
}

@ -1,32 +0,0 @@
package com.macro.mall.mapper; // 定义了该接口所属的包名用于Java的包管理
import com.macro.mall.model.OmsOrderOperateHistory; // 导入了OmsOrderOperateHistory实体类用于数据库表的映射
import com.macro.mall.model.OmsOrderOperateHistoryExample; // 导入了OmsOrderOperateHistoryExample类用于构建查询条件
import java.util.List; // 导入了List接口用于存储查询结果集
import org.apache.ibatis.annotations.Param; // 导入了MyBatis的Param注解用于指定参数名称
public interface OmsOrderOperateHistoryMapper { // 声明了一个MyBatis的Mapper接口用于数据库操作
// 以下方法都是MyBatis映射的方法用于数据库的CRUD操作
long countByExample(OmsOrderOperateHistoryExample example); // 根据example条件统计记录数
int deleteByExample(OmsOrderOperateHistoryExample example); // 根据example条件删除记录
int deleteByPrimaryKey(Long id); // 根据主键id删除记录
int insert(OmsOrderOperateHistory record); // 插入一条OmsOrderOperateHistory记录
int insertSelective(OmsOrderOperateHistory record); // 插入一条OmsOrderOperateHistory记录只插入不为null的字段
List<OmsOrderOperateHistory> selectByExample(OmsOrderOperateHistoryExample example); // 根据example条件查询OmsOrderOperateHistory记录
OmsOrderOperateHistory selectByPrimaryKey(Long id); // 根据主键id查询OmsOrderOperateHistory记录
int updateByExampleSelective(@Param("record") OmsOrderOperateHistory record, @Param("example") OmsOrderOperateHistoryExample example); // 根据example条件更新OmsOrderOperateHistory记录只更新不为null的字段
int updateByExample(@Param("record") OmsOrderOperateHistory record, @Param("example") OmsOrderOperateHistoryExample example); // 根据example条件更新OmsOrderOperateHistory记录
int updateByPrimaryKeySelective(OmsOrderOperateHistory record); // 根据主键id更新OmsOrderOperateHistory记录只更新不为null的字段
int updateByPrimaryKey(OmsOrderOperateHistory record); // 根据主键id更新OmsOrderOperateHistory记录
}

@ -1,32 +0,0 @@
package com.macro.mall.mapper; // 定义了该接口所属的包名用于Java的包管理
import com.macro.mall.model.OmsOrderReturnApply; // 导入了OmsOrderReturnApply实体类用于数据库表的映射
import com.macro.mall.model.OmsOrderReturnApplyExample; // 导入了OmsOrderReturnApplyExample类用于构建查询条件
import java.util.List; // 导入了List接口用于存储查询结果集
import org.apache.ibatis.annotations.Param; // 导入了MyBatis的Param注解用于指定参数名称
public interface OmsOrderReturnApplyMapper { // 声明了一个MyBatis的Mapper接口用于数据库操作
// 以下方法都是MyBatis映射的方法用于数据库的CRUD操作
long countByExample(OmsOrderReturnApplyExample example); // 根据example条件统计记录数
int deleteByExample(OmsOrderReturnApplyExample example); // 根据example条件删除记录
int deleteByPrimaryKey(Long id); // 根据主键id删除记录
int insert(OmsOrderReturnApply record); // 插入一条OmsOrderReturnApply记录
int insertSelective(OmsOrderReturnApply record); // 插入一条OmsOrderReturnApply记录只插入不为null的字段
List<OmsOrderReturnApply> selectByExample(OmsOrderReturnApplyExample example); // 根据example条件查询OmsOrderReturnApply记录
OmsOrderReturnApply selectByPrimaryKey(Long id); // 根据主键id查询OmsOrderReturnApply记录
int updateByExampleSelective(@Param("record") OmsOrderReturnApply record, @Param("example") OmsOrderReturnApplyExample example); // 根据example条件更新OmsOrderReturnApply记录只更新不为null的字段
int updateByExample(@Param("record") OmsOrderReturnApply record, @Param("example") OmsOrderReturnApplyExample example); // 根据example条件更新OmsOrderReturnApply记录
int updateByPrimaryKeySelective(OmsOrderReturnApply record); // 根据主键id更新OmsOrderReturnApply记录只更新不为null的字段
int updateByPrimaryKey(OmsOrderReturnApply record); // 根据主键id更新OmsOrderReturnApply记录
}

@ -1,32 +0,0 @@
package com.macro.mall.mapper; // 定义了该接口所属的包名用于Java的包管理
import com.macro.mall.model.OmsOrderReturnReason; // 导入了OmsOrderReturnReason实体类用于数据库表的映射
import com.macro.mall.model.OmsOrderReturnReasonExample; // 导入了OmsOrderReturnReasonExample类用于构建查询条件
import java.util.List; // 导入了List接口用于存储查询结果集
import org.apache.ibatis.annotations.Param; // 导入了MyBatis的Param注解用于指定参数名称
public interface OmsOrderReturnReasonMapper { // 声明了一个MyBatis的Mapper接口用于数据库操作
// 以下方法都是MyBatis映射的方法用于数据库的CRUD操作
long countByExample(OmsOrderReturnReasonExample example); // 根据example条件统计记录数
int deleteByExample(OmsOrderReturnReasonExample example); // 根据example条件删除记录
int deleteByPrimaryKey(Long id); // 根据主键id删除记录
int insert(OmsOrderReturnReason record); // 插入一条OmsOrderReturnReason记录
int insertSelective(OmsOrderReturnReason record); // 插入一条OmsOrderReturnReason记录只插入不为null的字段
List<OmsOrderReturnReason> selectByExample(OmsOrderReturnReasonExample example); // 根据example条件查询OmsOrderReturnReason记录
OmsOrderReturnReason selectByPrimaryKey(Long id); // 根据主键id查询OmsOrderReturnReason记录
int updateByExampleSelective(@Param("record") OmsOrderReturnReason record, @Param("example") OmsOrderReturnReasonExample example); // 根据example条件更新OmsOrderReturnReason记录只更新不为null的字段
int updateByExample(@Param("record") OmsOrderReturnReason record, @Param("example") OmsOrderReturnReasonExample example); // 根据example条件更新OmsOrderReturnReason记录
int updateByPrimaryKeySelective(OmsOrderReturnReason record); // 根据主键id更新OmsOrderReturnReason记录只更新不为null的字段
int updateByPrimaryKey(OmsOrderReturnReason record); // 根据主键id更新OmsOrderReturnReason记录
}

@ -1,32 +0,0 @@
package com.macro.mall.mapper; // 定义了该接口所属的包名用于Java的包管理
import com.macro.mall.model.OmsOrderSetting; // 导入了OmsOrderSetting实体类用于数据库表的映射
import com.macro.mall.model.OmsOrderSettingExample; // 导入了OmsOrderSettingExample类用于构建查询条件
import java.util.List; // 导入了List接口用于存储查询结果集
import org.apache.ibatis.annotations.Param; // 导入了MyBatis的Param注解用于指定参数名称
public interface OmsOrderSettingMapper { // 声明了一个MyBatis的Mapper接口用于数据库操作
// 以下方法都是MyBatis映射的方法用于数据库的CRUD操作
long countByExample(OmsOrderSettingExample example); // 根据example条件统计记录数
int deleteByExample(OmsOrderSettingExample example); // 根据example条件删除记录
int deleteByPrimaryKey(Long id); // 根据主键id删除记录
int insert(OmsOrderSetting record); // 插入一条OmsOrderSetting记录
int insertSelective(OmsOrderSetting record); // 插入一条OmsOrderSetting记录只插入不为null的字段
List<OmsOrderSetting> selectByExample(OmsOrderSettingExample example); // 根据example条件查询OmsOrderSetting记录
OmsOrderSetting selectByPrimaryKey(Long id); // 根据主键id查询OmsOrderSetting记录
int updateByExampleSelective(@Param("record") OmsOrderSetting record, @Param("example") OmsOrderSettingExample example); // 根据example条件更新OmsOrderSetting记录只更新不为null的字段
int updateByExample(@Param("record") OmsOrderSetting record, @Param("example") OmsOrderSettingExample example); // 根据example条件更新OmsOrderSetting记录
int updateByPrimaryKeySelective(OmsOrderSetting record); // 根据主键id更新OmsOrderSetting记录只更新不为null的字段
int updateByPrimaryKey(OmsOrderSetting record); // 根据主键id更新OmsOrderSetting记录
}

@ -1,32 +0,0 @@
package com.macro.mall.mapper; // 定义了该接口所属的包名用于Java的包管理
import com.macro.mall.model.PmsAlbum; // 导入了PmsAlbum实体类用于数据库表的映射
import com.macro.mall.model.PmsAlbumExample; // 导入了PmsAlbumExample类用于构建查询条件
import java.util.List; // 导入了List接口用于存储查询结果集
import org.apache.ibatis.annotations.Param; // 导入了MyBatis的Param注解用于指定参数名称
public interface PmsAlbumMapper { // 声明了一个MyBatis的Mapper接口用于数据库操作
// 以下方法都是MyBatis映射的方法用于数据库的CRUD操作
long countByExample(PmsAlbumExample example); // 根据example条件统计记录数
int deleteByExample(PmsAlbumExample example); // 根据example条件删除记录
int deleteByPrimaryKey(Long id); // 根据主键id删除记录
int insert(PmsAlbum record); // 插入一条PmsAlbum记录
int insertSelective(PmsAlbum record); // 插入一条PmsAlbum记录只插入不为null的字段
List<PmsAlbum> selectByExample(PmsAlbumExample example); // 根据example条件查询PmsAlbum记录
PmsAlbum selectByPrimaryKey(Long id); // 根据主键id查询PmsAlbum记录
int updateByExampleSelective(@Param("record") PmsAlbum record, @Param("example") PmsAlbumExample example); // 根据example条件更新PmsAlbum记录只更新不为null的字段
int updateByExample(@Param("record") PmsAlbum record, @Param("example") PmsAlbumExample example); // 根据example条件更新PmsAlbum记录
int updateByPrimaryKeySelective(PmsAlbum record); // 根据主键id更新PmsAlbum记录只更新不为null的字段
int updateByPrimaryKey(PmsAlbum record); // 根据主键id更新PmsAlbum记录
}

@ -1,32 +0,0 @@
package com.macro.mall.mapper; // 定义了该接口所属的包名用于Java的包管理
import com.macro.mall.model.PmsAlbumPic; // 导入了PmsAlbumPic实体类用于数据库表的映射
import com.macro.mall.model.PmsAlbumPicExample; // 导入了PmsAlbumPicExample类用于构建查询条件
import java.util.List; // 导入了List接口用于存储查询结果集
import org.apache.ibatis.annotations.Param; // 导入了MyBatis的Param注解用于指定参数名称
public interface PmsAlbumPicMapper { // 声明了一个MyBatis的Mapper接口用于数据库操作
// 以下方法都是MyBatis映射的方法用于数据库的CRUD操作
long countByExample(PmsAlbumPicExample example); // 根据example条件统计记录数
int deleteByExample(PmsAlbumPicExample example); // 根据example条件删除记录
int deleteByPrimaryKey(Long id); // 根据主键id删除记录
int insert(PmsAlbumPic record); // 插入一条PmsAlbumPic记录
int insertSelective(PmsAlbumPic record); // 插入一条PmsAlbumPic记录只插入不为null的字段
List<PmsAlbumPic> selectByExample(PmsAlbumPicExample example); // 根据example条件查询PmsAlbumPic记录
PmsAlbumPic selectByPrimaryKey(Long id); // 根据主键id查询PmsAlbumPic记录
int updateByExampleSelective(@Param("record") PmsAlbumPic record, @Param("example") PmsAlbumPicExample example); // 根据example条件更新PmsAlbumPic记录只更新不为null的字段
int updateByExample(@Param("record") PmsAlbumPic record, @Param("example") PmsAlbumPicExample example); // 根据example条件更新PmsAlbumPic记录
int updateByPrimaryKeySelective(PmsAlbumPic record); // 根据主键id更新PmsAlbumPic记录只更新不为null的字段
int updateByPrimaryKey(PmsAlbumPic record); // 根据主键id更新PmsAlbumPic记录
}

@ -1,38 +0,0 @@
package com.macro.mall.mapper; // 定义了该接口所属的包名用于Java的包管理
import com.macro.mall.model.PmsBrand; // 导入了PmsBrand实体类用于数据库表的映射
import com.macro.mall.model.PmsBrandExample; // 导入了PmsBrandExample类用于构建查询条件
import java.util.List; // 导入了List接口用于存储查询结果集
import org.apache.ibatis.annotations.Param; // 导入了MyBatis的Param注解用于指定参数名称
public interface PmsBrandMapper { // 声明了一个MyBatis的Mapper接口用于数据库操作
// 以下方法都是MyBatis映射的方法用于数据库的CRUD操作
long countByExample(PmsBrandExample example); // 根据example条件统计记录数
int deleteByExample(PmsBrandExample example); // 根据example条件删除记录
int deleteByPrimaryKey(Long id); // 根据主键id删除记录
int insert(PmsBrand record); // 插入一条PmsBrand记录
int insertSelective(PmsBrand record); // 插入一条PmsBrand记录只插入不为null的字段
List<PmsBrand> selectByExampleWithBLOBs(PmsBrandExample example); // 根据example条件查询PmsBrand记录包括BLOB字段
List<PmsBrand> selectByExample(PmsBrandExample example); // 根据example条件查询PmsBrand记录不包括BLOB字段
PmsBrand selectByPrimaryKey(Long id); // 根据主键id查询PmsBrand记录
int updateByExampleSelective(@Param("record") PmsBrand record, @Param("example") PmsBrandExample example); // 根据example条件更新PmsBrand记录只更新不为null的字段
int updateByExampleWithBLOBs(@Param("record") PmsBrand record, @Param("example") PmsBrandExample example); // 根据example条件更新PmsBrand记录包括BLOB字段
int updateByExample(@Param("record") PmsBrand record, @Param("example") PmsBrandExample example); // 根据example条件更新PmsBrand记录
int updateByPrimaryKeySelective(PmsBrand record); // 根据主键id更新PmsBrand记录只更新不为null的字段
int updateByPrimaryKeyWithBLOBs(PmsBrand record); // 根据主键id更新PmsBrand记录包括BLOB字段
int updateByPrimaryKey(PmsBrand record); // 根据主键id更新PmsBrand记录
}

@ -1,38 +0,0 @@
package com.macro.mall.mapper; // 定义了该接口所属的包名用于Java的包管理
import com.macro.mall.model.PmsComment; // 导入了PmsComment实体类用于数据库表的映射
import com.macro.mall.model.PmsCommentExample; // 导入了PmsCommentExample类用于构建查询条件
import java.util.List; // 导入了List接口用于存储查询结果集
import org.apache.ibatis.annotations.Param; // 导入了MyBatis的Param注解用于指定参数名称
public interface PmsCommentMapper { // 声明了一个MyBatis的Mapper接口用于数据库操作
// 以下方法都是MyBatis映射的方法用于数据库的CRUD操作
long countByExample(PmsCommentExample example); // 根据example条件统计记录数
int deleteByExample(PmsCommentExample example); // 根据example条件删除记录
int deleteByPrimaryKey(Long id); // 根据主键id删除记录
int insert(PmsComment record); // 插入一条PmsComment记录
int insertSelective(PmsComment record); // 插入一条PmsComment记录只插入不为null的字段
List<PmsComment> selectByExampleWithBLOBs(PmsCommentExample example); // 根据example条件查询PmsComment记录包括BLOB字段
List<PmsComment> selectByExample(PmsCommentExample example); // 根据example条件查询PmsComment记录不包括BLOB字段
PmsComment selectByPrimaryKey(Long id); // 根据主键id查询PmsComment记录
int updateByExampleSelective(@Param("record") PmsComment record, @Param("example") PmsCommentExample example); // 根据example条件更新PmsComment记录只更新不为null的字段
int updateByExampleWithBLOBs(@Param("record") PmsComment record, @Param("example") PmsCommentExample example); // 根据example条件更新PmsComment记录包括BLOB字段
int updateByExample(@Param("record") PmsComment record, @Param("example") PmsCommentExample example); // 根据example条件更新PmsComment记录
int updateByPrimaryKeySelective(PmsComment record); // 根据主键id更新PmsComment记录只更新不为null的字段
int updateByPrimaryKeyWithBLOBs(PmsComment record); // 根据主键id更新PmsComment记录包括BLOB字段
int updateByPrimaryKey(PmsComment record); // 根据主键id更新PmsComment记录
}

@ -1,32 +0,0 @@
package com.macro.mall.mapper; // 定义了该接口所属的包名用于Java的包管理
import com.macro.mall.model.PmsCommentReplay; // 导入了PmsCommentReplay实体类用于数据库表的映射
import com.macro.mall.model.PmsCommentReplayExample; // 导入了PmsCommentReplayExample类用于构建查询条件
import java.util.List; // 导入了List接口用于存储查询结果集
import org.apache.ibatis.annotations.Param; // 导入了MyBatis的Param注解用于指定参数名称
public interface PmsCommentReplayMapper { // 声明了一个MyBatis的Mapper接口用于数据库操作
// 以下方法都是MyBatis映射的方法用于数据库的CRUD操作
long countByExample(PmsCommentReplayExample example); // 根据example条件统计记录数
int deleteByExample(PmsCommentReplayExample example); // 根据example条件删除记录
int deleteByPrimaryKey(Long id); // 根据主键id删除记录
int insert(PmsCommentReplay record); // 插入一条PmsCommentReplay记录
int insertSelective(PmsCommentReplay record); // 插入一条PmsCommentReplay记录只插入不为null的字段
List<PmsCommentReplay> selectByExample(PmsCommentReplayExample example); // 根据example条件查询PmsCommentReplay记录
PmsCommentReplay selectByPrimaryKey(Long id); // 根据主键id查询PmsCommentReplay记录
int updateByExampleSelective(@Param("record") PmsCommentReplay record, @Param("example") PmsCommentReplayExample example); // 根据example条件更新PmsCommentReplay记录只更新不为null的字段
int updateByExample(@Param("record") PmsCommentReplay record, @Param("example") PmsCommentReplayExample example); // 根据example条件更新PmsCommentReplay记录
int updateByPrimaryKeySelective(PmsCommentReplay record); // 根据主键id更新PmsCommentReplay记录只更新不为null的字段
int updateByPrimaryKey(PmsCommentReplay record); // 根据主键id更新PmsCommentReplay记录
}

@ -1,32 +0,0 @@
package com.macro.mall.mapper; // 定义了该接口所属的包名用于Java的包管理
import com.macro.mall.model.PmsFeightTemplate; // 导入了PmsFeightTemplate实体类用于数据库表的映射
import com.macro.mall.model.PmsFeightTemplateExample; // 导入了PmsFeightTemplateExample类用于构建查询条件
import java.util.List; // 导入了List接口用于存储查询结果集
import org.apache.ibatis.annotations.Param; // 导入了MyBatis的Param注解用于指定参数名称
public interface PmsFeightTemplateMapper { // 声明了一个MyBatis的Mapper接口用于数据库操作
// 以下方法都是MyBatis映射的方法用于数据库的CRUD操作
long countByExample(PmsFeightTemplateExample example); // 根据example条件统计记录数
int deleteByExample(PmsFeightTemplateExample example); // 根据example条件删除记录
int deleteByPrimaryKey(Long id); // 根据主键id删除记录
int insert(PmsFeightTemplate record); // 插入一条PmsFeightTemplate记录
int insertSelective(PmsFeightTemplate record); // 插入一条PmsFeightTemplate记录只插入不为null的字段
List<PmsFeightTemplate> selectByExample(PmsFeightTemplateExample example); // 根据example条件查询PmsFeightTemplate记录
PmsFeightTemplate selectByPrimaryKey(Long id); // 根据主键id查询PmsFeightTemplate记录
int updateByExampleSelective(@Param("record") PmsFeightTemplate record, @Param("example") PmsFeightTemplateExample example); // 根据example条件更新PmsFeightTemplate记录只更新不为null的字段
int updateByExample(@Param("record") PmsFeightTemplate record, @Param("example") PmsFeightTemplateExample example); // 根据example条件更新PmsFeightTemplate记录
int updateByPrimaryKeySelective(PmsFeightTemplate record); // 根据主键id更新PmsFeightTemplate记录只更新不为null的字段
int updateByPrimaryKey(PmsFeightTemplate record); // 根据主键id更新PmsFeightTemplate记录
}

@ -1,32 +0,0 @@
package com.macro.mall.mapper; // 定义了该接口所属的包名用于Java的包管理
import com.macro.mall.model.PmsMemberPrice; // 导入了PmsMemberPrice实体类用于数据库表的映射
import com.macro.mall.model.PmsMemberPriceExample; // 导入了PmsMemberPriceExample类用于构建查询条件
import java.util.List; // 导入了List接口用于存储查询结果集
import org.apache.ibatis.annotations.Param; // 导入了MyBatis的Param注解用于指定参数名称
public interface PmsMemberPriceMapper { // 声明了一个MyBatis的Mapper接口用于数据库操作
// 以下方法都是MyBatis映射的方法用于数据库的CRUD操作
long countByExample(PmsMemberPriceExample example); // 根据example条件统计记录数
int deleteByExample(PmsMemberPriceExample example); // 根据example条件删除记录
int deleteByPrimaryKey(Long id); // 根据主键id删除记录
int insert(PmsMemberPrice record); // 插入一条PmsMemberPrice记录
int insertSelective(PmsMemberPrice record); // 插入一条PmsMemberPrice记录只插入不为null的字段
List<PmsMemberPrice> selectByExample(PmsMemberPriceExample example); // 根据example条件查询PmsMemberPrice记录
PmsMemberPrice selectByPrimaryKey(Long id); // 根据主键id查询PmsMemberPrice记录
int updateByExampleSelective(@Param("record") PmsMemberPrice record, @Param("example") PmsMemberPriceExample example); // 根据example条件更新PmsMemberPrice记录只更新不为null的字段
int updateByExample(@Param("record") PmsMemberPrice record, @Param("example") PmsMemberPriceExample example); // 根据example条件更新PmsMemberPrice记录
int updateByPrimaryKeySelective(PmsMemberPrice record); // 根据主键id更新PmsMemberPrice记录只更新不为null的字段
int updateByPrimaryKey(PmsMemberPrice record); // 根据主键id更新PmsMemberPrice记录
}

@ -1,32 +0,0 @@
package com.macro.mall.mapper; // 定义了该接口所属的包名用于Java的包管理
import com.macro.mall.model.PmsProductAttributeCategory; // 导入了PmsProductAttributeCategory实体类用于数据库表的映射
import com.macro.mall.model.PmsProductAttributeCategoryExample; // 导入了PmsProductAttributeCategoryExample类用于构建查询条件
import java.util.List; // 导入了List接口用于存储查询结果集
import org.apache.ibatis.annotations.Param; // 导入了MyBatis的Param注解用于指定参数名称
public interface PmsProductAttributeCategoryMapper { // 声明了一个MyBatis的Mapper接口用于数据库操作
// 以下方法都是MyBatis映射的方法用于数据库的CRUD操作
long countByExample(PmsProductAttributeCategoryExample example); // 根据example条件统计记录数
int deleteByExample(PmsProductAttributeCategoryExample example); // 根据example条件删除记录
int deleteByPrimaryKey(Long id); // 根据主键id删除记录
int insert(PmsProductAttributeCategory record); // 插入一条PmsProductAttributeCategory记录
int insertSelective(PmsProductAttributeCategory record); // 插入一条PmsProductAttributeCategory记录只插入不为null的字段
List<PmsProductAttributeCategory> selectByExample(PmsProductAttributeCategoryExample example); // 根据example条件查询PmsProductAttributeCategory记录
PmsProductAttributeCategory selectByPrimaryKey(Long id); // 根据主键id查询PmsProductAttributeCategory记录
int updateByExampleSelective(@Param("record") PmsProductAttributeCategory record, @Param("example") PmsProductAttributeCategoryExample example); // 根据example条件更新PmsProductAttributeCategory记录只更新不为null的字段
int updateByExample(@Param("record") PmsProductAttributeCategory record, @Param("example") PmsProductAttributeCategoryExample example); // 根据example条件更新PmsProductAttributeCategory记录
int updateByPrimaryKeySelective(PmsProductAttributeCategory record); // 根据主键id更新PmsProductAttributeCategory记录只更新不为null的字段
int updateByPrimaryKey(PmsProductAttributeCategory record); // 根据主键id更新PmsProductAttributeCategory记录
}

@ -1,32 +0,0 @@
package com.macro.mall.mapper; // 定义了该接口所属的包名用于Java的包管理
import com.macro.mall.model.PmsProductAttribute; // 导入了PmsProductAttribute实体类用于数据库表的映射
import com.macro.mall.model.PmsProductAttributeExample; // 导入了PmsProductAttributeExample类用于构建查询条件
import java.util.List; // 导入了List接口用于存储查询结果集
import org.apache.ibatis.annotations.Param; // 导入了MyBatis的Param注解用于指定参数名称
public interface PmsProductAttributeMapper { // 声明了一个MyBatis的Mapper接口用于数据库操作
// 以下方法都是MyBatis映射的方法用于数据库的CRUD操作
long countByExample(PmsProductAttributeExample example); // 根据example条件统计记录数
int deleteByExample(PmsProductAttributeExample example); // 根据example条件删除记录
int deleteByPrimaryKey(Long id); // 根据主键id删除记录
int insert(PmsProductAttribute record); // 插入一条PmsProductAttribute记录
int insertSelective(PmsProductAttribute record); // 插入一条PmsProductAttribute记录只插入不为null的字段
List<PmsProductAttribute> selectByExample(PmsProductAttributeExample example); // 根据example条件查询PmsProductAttribute记录
PmsProductAttribute selectByPrimaryKey(Long id); // 根据主键id查询PmsProductAttribute记录
int updateByExampleSelective(@Param("record") PmsProductAttribute record, @Param("example") PmsProductAttributeExample example); // 根据example条件更新PmsProductAttribute记录只更新不为null的字段
int updateByExample(@Param("record") PmsProductAttribute record, @Param("example") PmsProductAttributeExample example); // 根据example条件更新PmsProductAttribute记录
int updateByPrimaryKeySelective(PmsProductAttribute record); // 根据主键id更新PmsProductAttribute记录只更新不为null的字段
int updateByPrimaryKey(PmsProductAttribute record); // 根据主键id更新PmsProductAttribute记录
}

@ -1,32 +0,0 @@
package com.macro.mall.mapper; // 定义了该接口所属的包名用于Java的包管理
import com.macro.mall.model.PmsProductAttributeValue; // 导入了PmsProductAttributeValue实体类用于数据库表的映射
import com.macro.mall.model.PmsProductAttributeValueExample; // 导入了PmsProductAttributeValueExample类用于构建查询条件
import java.util.List; // 导入了List接口用于存储查询结果集
import org.apache.ibatis.annotations.Param; // 导入了MyBatis的Param注解用于指定参数名称
public interface PmsProductAttributeValueMapper { // 声明了一个MyBatis的Mapper接口用于数据库操作
// 以下方法都是MyBatis映射的方法用于数据库的CRUD操作
long countByExample(PmsProductAttributeValueExample example); // 根据example条件统计记录数
int deleteByExample(PmsProductAttributeValueExample example); // 根据example条件删除记录
int deleteByPrimaryKey(Long id); // 根据主键id删除记录
int insert(PmsProductAttributeValue record); // 插入一条PmsProductAttributeValue记录
int insertSelective(PmsProductAttributeValue record); // 插入一条PmsProductAttributeValue记录只插入不为null的字段
List<PmsProductAttributeValue> selectByExample(PmsProductAttributeValueExample example); // 根据example条件查询PmsProductAttributeValue记录
PmsProductAttributeValue selectByPrimaryKey(Long id); // 根据主键id查询PmsProductAttributeValue记录
int updateByExampleSelective(@Param("record") PmsProductAttributeValue record, @Param("example") PmsProductAttributeValueExample example); // 根据example条件更新PmsProductAttributeValue记录只更新不为null的字段
int updateByExample(@Param("record") PmsProductAttributeValue record, @Param("example") PmsProductAttributeValueExample example); // 根据example条件更新PmsProductAttributeValue记录
int updateByPrimaryKeySelective(PmsProductAttributeValue record); // 根据主键id更新PmsProductAttributeValue记录只更新不为null的字段
int updateByPrimaryKey(PmsProductAttributeValue record); // 根据主键id更新PmsProductAttributeValue记录
}

@ -1,32 +0,0 @@
package com.macro.mall.mapper; // 定义了该接口所属的包名用于Java的包管理
import com.macro.mall.model.PmsProductCategoryAttributeRelation; // 导入了PmsProductCategoryAttributeRelation实体类用于数据库表的映射
import com.macro.mall.model.PmsProductCategoryAttributeRelationExample; // 导入了PmsProductCategoryAttributeRelationExample类用于构建查询条件
import java.util.List; // 导入了List接口用于存储查询结果集
import org.apache.ibatis.annotations.Param; // 导入了MyBatis的Param注解用于指定参数名称
public interface PmsProductCategoryAttributeRelationMapper { // 声明了一个MyBatis的Mapper接口用于数据库操作
// 以下方法都是MyBatis映射的方法用于数据库的CRUD操作
long countByExample(PmsProductCategoryAttributeRelationExample example); // 根据example条件统计记录数
int deleteByExample(PmsProductCategoryAttributeRelationExample example); // 根据example条件删除记录
int deleteByPrimaryKey(Long id); // 根据主键id删除记录
int insert(PmsProductCategoryAttributeRelation record); // 插入一条PmsProductCategoryAttributeRelation记录
int insertSelective(PmsProductCategoryAttributeRelation record); // 插入一条PmsProductCategoryAttributeRelation记录只插入不为null的字段
List<PmsProductCategoryAttributeRelation> selectByExample(PmsProductCategoryAttributeRelationExample example); // 根据example条件查询PmsProductCategoryAttributeRelation记录
PmsProductCategoryAttributeRelation selectByPrimaryKey(Long id); // 根据主键id查询PmsProductCategoryAttributeRelation记录
int updateByExampleSelective(@Param("record") PmsProductCategoryAttributeRelation record, @Param("example") PmsProductCategoryAttributeRelationExample example); // 根据example条件更新PmsProductCategoryAttributeRelation记录只更新不为null的字段
int updateByExample(@Param("record") PmsProductCategoryAttributeRelation record, @Param("example") PmsProductCategoryAttributeRelationExample example); // 根据example条件更新PmsProductCategoryAttributeRelation记录
int updateByPrimaryKeySelective(PmsProductCategoryAttributeRelation record); // 根据主键id更新PmsProductCategoryAttributeRelation记录只更新不为null的字段
int updateByPrimaryKey(PmsProductCategoryAttributeRelation record); // 根据主键id更新PmsProductCategoryAttributeRelation记录
}

@ -1,38 +0,0 @@
package com.macro.mall.mapper; // 定义了该接口所属的包名用于Java的包管理
import com.macro.mall.model.PmsProductCategory; // 导入了PmsProductCategory实体类用于数据库表的映射
import com.macro.mall.model.PmsProductCategoryExample; // 导入了PmsProductCategoryExample类用于构建查询条件
import java.util.List; // 导入了List接口用于存储查询结果集
import org.apache.ibatis.annotations.Param; // 导入了MyBatis的Param注解用于指定参数名称
public interface PmsProductCategoryMapper { // 声明了一个MyBatis的Mapper接口用于数据库操作
// 以下方法都是MyBatis映射的方法用于数据库的CRUD操作
long countByExample(PmsProductCategoryExample example); // 根据example条件统计记录数
int deleteByExample(PmsProductCategoryExample example); // 根据example条件删除记录
int deleteByPrimaryKey(Long id); // 根据主键id删除记录
int insert(PmsProductCategory record); // 插入一条PmsProductCategory记录
int insertSelective(PmsProductCategory record); // 插入一条PmsProductCategory记录只插入不为null的字段
List<PmsProductCategory> selectByExampleWithBLOBs(PmsProductCategoryExample example); // 根据example条件查询PmsProductCategory记录包括BLOB字段
List<PmsProductCategory> selectByExample(PmsProductCategoryExample example); // 根据example条件查询PmsProductCategory记录不包括BLOB字段
PmsProductCategory selectByPrimaryKey(Long id); // 根据主键id查询PmsProductCategory记录
int updateByExampleSelective(@Param("record") PmsProductCategory record, @Param("example") PmsProductCategoryExample example); // 根据example条件更新PmsProductCategory记录只更新不为null的字段
int updateByExampleWithBLOBs(@Param("record") PmsProductCategory record, @Param("example") PmsProductCategoryExample example); // 根据example条件更新PmsProductCategory记录包括BLOB字段
int updateByExample(@Param("record") PmsProductCategory record, @Param("example") PmsProductCategoryExample example); // 根据example条件更新PmsProductCategory记录
int updateByPrimaryKeySelective(PmsProductCategory record); // 根据主键id更新PmsProductCategory记录只更新不为null的字段
int updateByPrimaryKeyWithBLOBs(PmsProductCategory record); // 根据主键id更新PmsProductCategory记录包括BLOB字段
int updateByPrimaryKey(PmsProductCategory record); // 根据主键id更新PmsProductCategory记录
}

@ -1,32 +0,0 @@
package com.macro.mall.mapper; // 定义了该接口所属的包名用于Java的包管理
import com.macro.mall.model.PmsProductFullReduction; // 导入了PmsProductFullReduction实体类用于数据库表的映射
import com.macro.mall.model.PmsProductFullReductionExample; // 导入了PmsProductFullReductionExample类用于构建查询条件
import java.util.List; // 导入了List接口用于存储查询结果集
import org.apache.ibatis.annotations.Param; // 导入了MyBatis的Param注解用于指定参数名称
public interface PmsProductFullReductionMapper { // 声明了一个MyBatis的Mapper接口用于数据库操作
// 以下方法都是MyBatis映射的方法用于数据库的CRUD操作
long countByExample(PmsProductFullReductionExample example); // 根据example条件统计记录数
int deleteByExample(PmsProductFullReductionExample example); // 根据example条件删除记录
int deleteByPrimaryKey(Long id); // 根据主键id删除记录
int insert(PmsProductFullReduction record); // 插入一条PmsProductFullReduction记录
int insertSelective(PmsProductFullReduction record); // 插入一条PmsProductFullReduction记录只插入不为null的字段
List<PmsProductFullReduction> selectByExample(PmsProductFullReductionExample example); // 根据example条件查询PmsProductFullReduction记录
PmsProductFullReduction selectByPrimaryKey(Long id); // 根据主键id查询PmsProductFullReduction记录
int updateByExampleSelective(@Param("record") PmsProductFullReduction record, @Param("example") PmsProductFullReductionExample example); // 根据example条件更新PmsProductFullReduction记录只更新不为null的字段
int updateByExample(@Param("record") PmsProductFullReduction record, @Param("example") PmsProductFullReductionExample example); // 根据example条件更新PmsProductFullReduction记录
int updateByPrimaryKeySelective(PmsProductFullReduction record); // 根据主键id更新PmsProductFullReduction记录只更新不为null的字段
int updateByPrimaryKey(PmsProductFullReduction record); // 根据主键id更新PmsProductFullReduction记录
}

@ -1,32 +0,0 @@
package com.macro.mall.mapper; // 定义了该接口所属的包名用于Java的包管理
import com.macro.mall.model.PmsProductLadder; // 导入了PmsProductLadder实体类用于数据库表的映射
import com.macro.mall.model.PmsProductLadderExample; // 导入了PmsProductLadderExample类用于构建查询条件
import java.util.List; // 导入了List接口用于存储查询结果集
import org.apache.ibatis.annotations.Param; // 导入了MyBatis的Param注解用于指定参数名称
public interface PmsProductLadderMapper { // 声明了一个MyBatis的Mapper接口用于数据库操作
// 以下方法都是MyBatis映射的方法用于数据库的CRUD操作
long countByExample(PmsProductLadderExample example); // 根据example条件统计记录数
int deleteByExample(PmsProductLadderExample example); // 根据example条件删除记录
int deleteByPrimaryKey(Long id); // 根据主键id删除记录
int insert(PmsProductLadder record); // 插入一条PmsProductLadder记录
int insertSelective(PmsProductLadder record); // 插入一条PmsProductLadder记录只插入不为null的字段
List<PmsProductLadder> selectByExample(PmsProductLadderExample example); // 根据example条件查询PmsProductLadder记录
PmsProductLadder selectByPrimaryKey(Long id); // 根据主键id查询PmsProductLadder记录
int updateByExampleSelective(@Param("record") PmsProductLadder record, @Param("example") PmsProductLadderExample example); // 根据example条件更新PmsProductLadder记录只更新不为null的字段
int updateByExample(@Param("record") PmsProductLadder record, @Param("example") PmsProductLadderExample example); // 根据example条件更新PmsProductLadder记录
int updateByPrimaryKeySelective(PmsProductLadder record); // 根据主键id更新PmsProductLadder记录只更新不为null的字段
int updateByPrimaryKey(PmsProductLadder record); // 根据主键id更新PmsProductLadder记录
}

@ -1,38 +0,0 @@
package com.macro.mall.mapper; // 定义了该接口所属的包名用于Java的包管理
import com.macro.mall.model.PmsProduct; // 导入了PmsProduct实体类用于数据库表的映射
import com.macro.mall.model.PmsProductExample; // 导入了PmsProductExample类用于构建查询条件
import java.util.List; // 导入了List接口用于存储查询结果集
import org.apache.ibatis.annotations.Param; // 导入了MyBatis的Param注解用于指定参数名称
public interface PmsProductMapper { // 声明了一个MyBatis的Mapper接口用于数据库操作
// 以下方法都是MyBatis映射的方法用于数据库的CRUD操作
long countByExample(PmsProductExample example); // 根据example条件统计记录数
int deleteByExample(PmsProductExample example); // 根据example条件删除记录
int deleteByPrimaryKey(Long id); // 根据主键id删除记录
int insert(PmsProduct record); // 插入一条PmsProduct记录
int insertSelective(PmsProduct record); // 插入一条PmsProduct记录只插入不为null的字段
List<PmsProduct> selectByExampleWithBLOBs(PmsProductExample example); // 根据example条件查询PmsProduct记录包括BLOB字段
List<PmsProduct> selectByExample(PmsProductExample example); // 根据example条件查询PmsProduct记录不包括BLOB字段
PmsProduct selectByPrimaryKey(Long id); // 根据主键id查询PmsProduct记录
int updateByExampleSelective(@Param("record") PmsProduct record, @Param("example") PmsProductExample example); // 根据example条件更新PmsProduct记录只更新不为null的字段
int updateByExampleWithBLOBs(@Param("record") PmsProduct record, @Param("example") PmsProductExample example); // 根据example条件更新PmsProduct记录包括BLOB字段
int updateByExample(@Param("record") PmsProduct record, @Param("example") PmsProductExample example); // 根据example条件更新PmsProduct记录
int updateByPrimaryKeySelective(PmsProduct record); // 根据主键id更新PmsProduct记录只更新不为null的字段
int updateByPrimaryKeyWithBLOBs(PmsProduct record); // 根据主键id更新PmsProduct记录包括BLOB字段
int updateByPrimaryKey(PmsProduct record); // 根据主键id更新PmsProduct记录
}

@ -1,32 +0,0 @@
package com.macro.mall.mapper; // 定义了该接口所属的包名用于Java的包管理
import com.macro.mall.model.PmsProductOperateLog; // 导入了PmsProductOperateLog实体类用于数据库表的映射
import com.macro.mall.model.PmsProductOperateLogExample; // 导入了PmsProductOperateLogExample类用于构建查询条件
import java.util.List; // 导入了List接口用于存储查询结果集
import org.apache.ibatis.annotations.Param; // 导入了MyBatis的Param注解用于指定参数名称
public interface PmsProductOperateLogMapper { // 声明了一个MyBatis的Mapper接口用于数据库操作
// 以下方法都是MyBatis映射的方法用于数据库的CRUD操作
long countByExample(PmsProductOperateLogExample example); // 根据example条件统计记录数
int deleteByExample(PmsProductOperateLogExample example); // 根据example条件删除记录
int deleteByPrimaryKey(Long id); // 根据主键id删除记录
int insert(PmsProductOperateLog record); // 插入一条PmsProductOperateLog记录
int insertSelective(PmsProductOperateLog record); // 插入一条PmsProductOperateLog记录只插入不为null的字段
List<PmsProductOperateLog> selectByExample(PmsProductOperateLogExample example); // 根据example条件查询PmsProductOperateLog记录
PmsProductOperateLog selectByPrimaryKey(Long id); // 根据主键id查询PmsProductOperateLog记录
int updateByExampleSelective(@Param("record") PmsProductOperateLog record, @Param("example") PmsProductOperateLogExample example); // 根据example条件更新PmsProductOperateLog记录只更新不为null的字段
int updateByExample(@Param("record") PmsProductOperateLog record, @Param("example") PmsProductOperateLogExample example); // 根据example条件更新PmsProductOperateLog记录
int updateByPrimaryKeySelective(PmsProductOperateLog record); // 根据主键id更新PmsProductOperateLog记录只更新不为null的字段
int updateByPrimaryKey(PmsProductOperateLog record); // 根据主键id更新PmsProductOperateLog记录
}

@ -1,32 +0,0 @@
package com.macro.mall.mapper; // 定义了该接口所属的包名用于Java的包管理
import com.macro.mall.model.PmsProductVertifyRecord; // 导入了PmsProductVertifyRecord实体类用于数据库表的映射
import com.macro.mall.model.PmsProductVertifyRecordExample; // 导入了PmsProductVertifyRecordExample类用于构建查询条件
import java.util.List; // 导入了List接口用于存储查询结果集
import org.apache.ibatis.annotations.Param; // 导入了MyBatis的Param注解用于指定参数名称
public interface PmsProductVertifyRecordMapper { // 声明了一个MyBatis的Mapper接口用于数据库操作
// 以下方法都是MyBatis映射的方法用于数据库的CRUD操作
long countByExample(PmsProductVertifyRecordExample example); // 根据example条件统计记录数
int deleteByExample(PmsProductVertifyRecordExample example); // 根据example条件删除记录
int deleteByPrimaryKey(Long id); // 根据主键id删除记录
int insert(PmsProductVertifyRecord record); // 插入一条PmsProductVertifyRecord记录
int insertSelective(PmsProductVertifyRecord record); // 插入一条PmsProductVertifyRecord记录只插入不为null的字段
List<PmsProductVertifyRecord> selectByExample(PmsProductVertifyRecordExample example); // 根据example条件查询PmsProductVertifyRecord记录
PmsProductVertifyRecord selectByPrimaryKey(Long id); // 根据主键id查询PmsProductVertifyRecord记录
int updateByExampleSelective(@Param("record") PmsProductVertifyRecord record, @Param("example") PmsProductVertifyRecordExample example); // 根据example条件更新PmsProductVertifyRecord记录只更新不为null的字段
int updateByExample(@Param("record") PmsProductVertifyRecord record, @Param("example") PmsProductVertifyRecordExample example); // 根据example条件更新PmsProductVertifyRecord记录
int updateByPrimaryKeySelective(PmsProductVertifyRecord record); // 根据主键id更新PmsProductVertifyRecord记录只更新不为null的字段
int updateByPrimaryKey(PmsProductVertifyRecord record); // 根据主键id更新PmsProductVertifyRecord记录
}

@ -1,32 +0,0 @@
package com.macro.mall.mapper; // 定义了该接口所属的包名用于Java的包管理
import com.macro.mall.model.PmsSkuStock; // 导入了PmsSkuStock实体类用于数据库表的映射
import com.macro.mall.model.PmsSkuStockExample; // 导入了PmsSkuStockExample类用于构建查询条件
import java.util.List; // 导入了List接口用于存储查询结果集
import org.apache.ibatis.annotations.Param; // 导入了MyBatis的Param注解用于指定参数名称
public interface PmsSkuStockMapper { // 声明了一个MyBatis的Mapper接口用于数据库操作
// 以下方法都是MyBatis映射的方法用于数据库的CRUD操作
long countByExample(PmsSkuStockExample example); // 根据example条件统计记录数
int deleteByExample(PmsSkuStockExample example); // 根据example条件删除记录
int deleteByPrimaryKey(Long id); // 根据主键id删除记录
int insert(PmsSkuStock record); // 插入一条PmsSkuStock记录
int insertSelective(PmsSkuStock record); // 插入一条PmsSkuStock记录只插入不为null的字段
List<PmsSkuStock> selectByExample(PmsSkuStockExample example); // 根据example条件查询PmsSkuStock记录
PmsSkuStock selectByPrimaryKey(Long id); // 根据主键id查询PmsSkuStock记录
int updateByExampleSelective(@Param("record") PmsSkuStock record, @Param("example") PmsSkuStockExample example); // 根据example条件更新PmsSkuStock记录只更新不为null的字段
int updateByExample(@Param("record") PmsSkuStock record, @Param("example") PmsSkuStockExample example); // 根据example条件更新PmsSkuStock记录
int updateByPrimaryKeySelective(PmsSkuStock record); // 根据主键id更新PmsSkuStock记录只更新不为null的字段
int updateByPrimaryKey(PmsSkuStock record); // 根据主键id更新PmsSkuStock记录
}

@ -1,32 +0,0 @@
package com.macro.mall.mapper; // 定义了该接口所属的包名用于Java的包管理
import com.macro.mall.model.SmsCouponHistory; // 导入了SmsCouponHistory实体类用于数据库表的映射
import com.macro.mall.model.SmsCouponHistoryExample; // 导入了SmsCouponHistoryExample类用于构建查询条件
import java.util.List; // 导入了List接口用于存储查询结果集
import org.apache.ibatis.annotations.Param; // 导入了MyBatis的Param注解用于指定参数名称
public interface SmsCouponHistoryMapper { // 声明了一个MyBatis的Mapper接口用于数据库操作
// 以下方法都是MyBatis映射的方法用于数据库的CRUD操作
long countByExample(SmsCouponHistoryExample example); // 根据example条件统计记录数
int deleteByExample(SmsCouponHistoryExample example); // 根据example条件删除记录
int deleteByPrimaryKey(Long id); // 根据主键id删除记录
int insert(SmsCouponHistory record); // 插入一条SmsCouponHistory记录
int insertSelective(SmsCouponHistory record); // 插入一条SmsCouponHistory记录只插入不为null的字段
List<SmsCouponHistory> selectByExample(SmsCouponHistoryExample example); // 根据example条件查询SmsCouponHistory记录
SmsCouponHistory selectByPrimaryKey(Long id); // 根据主键id查询SmsCouponHistory记录
int updateByExampleSelective(@Param("record") SmsCouponHistory record, @Param("example") SmsCouponHistoryExample example); // 根据example条件更新SmsCouponHistory记录只更新不为null的字段
int updateByExample(@Param("record") SmsCouponHistory record, @Param("example") SmsCouponHistoryExample example); // 根据example条件更新SmsCouponHistory记录
int updateByPrimaryKeySelective(SmsCouponHistory record); // 根据主键id更新SmsCouponHistory记录只更新不为null的字段
int updateByPrimaryKey(SmsCouponHistory record); // 根据主键id更新SmsCouponHistory记录
}

@ -1,32 +0,0 @@
package com.macro.mall.mapper; // 定义了该接口所属的包名用于Java的包管理
import com.macro.mall.model.SmsCoupon; // 导入了SmsCoupon实体类用于数据库表的映射
import com.macro.mall.model.SmsCouponExample; // 导入了SmsCouponExample类用于构建查询条件
import java.util.List; // 导入了List接口用于存储查询结果集
import org.apache.ibatis.annotations.Param; // 导入了MyBatis的Param注解用于指定参数名称
public interface SmsCouponMapper { // 声明了一个MyBatis的Mapper接口用于数据库操作
// 以下方法都是MyBatis映射的方法用于数据库的CRUD操作
long countByExample(SmsCouponExample example); // 根据example条件统计记录数
int deleteByExample(SmsCouponExample example); // 根据example条件删除记录
int deleteByPrimaryKey(Long id); // 根据主键id删除记录
int insert(SmsCoupon record); // 插入一条SmsCoupon记录
int insertSelective(SmsCoupon record); // 插入一条SmsCoupon记录只插入不为null的字段
List<SmsCoupon> selectByExample(SmsCouponExample example); // 根据example条件查询SmsCoupon记录
SmsCoupon selectByPrimaryKey(Long id); // 根据主键id查询SmsCoupon记录
int updateByExampleSelective(@Param("record") SmsCoupon record, @Param("example") SmsCouponExample example); // 根据example条件更新SmsCoupon记录只更新不为null的字段
int updateByExample(@Param("record") SmsCoupon record, @Param("example") SmsCouponExample example); // 根据example条件更新SmsCoupon记录
int updateByPrimaryKeySelective(SmsCoupon record); // 根据主键id更新SmsCoupon记录只更新不为null的字段
int updateByPrimaryKey(SmsCoupon record); // 根据主键id更新SmsCoupon记录
}

@ -1,32 +0,0 @@
package com.macro.mall.mapper; // 定义了该接口所属的包名用于Java的包管理
import com.macro.mall.model.SmsCouponProductCategoryRelation; // 导入了SmsCouponProductCategoryRelation实体类用于数据库表的映射
import com.macro.mall.model.SmsCouponProductCategoryRelationExample; // 导入了SmsCouponProductCategoryRelationExample类用于构建查询条件
import java.util.List; // 导入了List接口用于存储查询结果集
import org.apache.ibatis.annotations.Param; // 导入了MyBatis的Param注解用于指定参数名称
public interface SmsCouponProductCategoryRelationMapper { // 声明了一个MyBatis的Mapper接口用于数据库操作
// 以下方法都是MyBatis映射的方法用于数据库的CRUD操作
long countByExample(SmsCouponProductCategoryRelationExample example); // 根据example条件统计记录数
int deleteByExample(SmsCouponProductCategoryRelationExample example); // 根据example条件删除记录
int deleteByPrimaryKey(Long id); // 根据主键id删除记录
int insert(SmsCouponProductCategoryRelation record); // 插入一条SmsCouponProductCategoryRelation记录
int insertSelective(SmsCouponProductCategoryRelation record); // 插入一条SmsCouponProductCategoryRelation记录只插入不为null的字段
List<SmsCouponProductCategoryRelation> selectByExample(SmsCouponProductCategoryRelationExample example); // 根据example条件查询SmsCouponProductCategoryRelation记录
SmsCouponProductCategoryRelation selectByPrimaryKey(Long id); // 根据主键id查询SmsCouponProductCategoryRelation记录
int updateByExampleSelective(@Param("record") SmsCouponProductCategoryRelation record, @Param("example") SmsCouponProductCategoryRelationExample example); // 根据example条件更新SmsCouponProductCategoryRelation记录只更新不为null的字段
int updateByExample(@Param("record") SmsCouponProductCategoryRelation record, @Param("example") SmsCouponProductCategoryRelationExample example); // 根据example条件更新SmsCouponProductCategoryRelation记录
int updateByPrimaryKeySelective(SmsCouponProductCategoryRelation record); // 根据主键id更新SmsCouponProductCategoryRelation记录只更新不为null的字段
int updateByPrimaryKey(SmsCouponProductCategoryRelation record); // 根据主键id更新SmsCouponProductCategoryRelation记录
}

@ -1,32 +0,0 @@
package com.macro.mall.mapper; // 定义了该接口所属的包名用于Java的包管理
import com.macro.mall.model.SmsCouponProductRelation; // 导入了SmsCouponProductRelation实体类用于数据库表的映射
import com.macro.mall.model.SmsCouponProductRelationExample; // 导入了SmsCouponProductRelationExample类用于构建查询条件
import java.util.List; // 导入了List接口用于存储查询结果集
import org.apache.ibatis.annotations.Param; // 导入了MyBatis的Param注解用于指定参数名称
public interface SmsCouponProductRelationMapper { // 声明了一个MyBatis的Mapper接口用于数据库操作
// 以下方法都是MyBatis映射的方法用于数据库的CRUD操作
long countByExample(SmsCouponProductRelationExample example); // 根据example条件统计记录数
int deleteByExample(SmsCouponProductRelationExample example); // 根据example条件删除记录
int deleteByPrimaryKey(Long id); // 根据主键id删除记录
int insert(SmsCouponProductRelation record); // 插入一条SmsCouponProductRelation记录
int insertSelective(SmsCouponProductRelation record); // 插入一条SmsCouponProductRelation记录只插入不为null的字段
List<SmsCouponProductRelation> selectByExample(SmsCouponProductRelationExample example); // 根据example条件查询SmsCouponProductRelation记录
SmsCouponProductRelation selectByPrimaryKey(Long id); // 根据主键id查询SmsCouponProductRelation记录
int updateByExampleSelective(@Param("record") SmsCouponProductRelation record, @Param("example") SmsCouponProductRelationExample example); // 根据example条件更新SmsCouponProductRelation记录只更新不为null的字段
int updateByExample(@Param("record") SmsCouponProductRelation record, @Param("example") SmsCouponProductRelationExample example); // 根据example条件更新SmsCouponProductRelation记录
int updateByPrimaryKeySelective(SmsCouponProductRelation record); // 根据主键id更新SmsCouponProductRelation记录只更新不为null的字段
int updateByPrimaryKey(SmsCouponProductRelation record); // 根据主键id更新SmsCouponProductRelation记录
}

@ -1,32 +0,0 @@
package com.macro.mall.mapper; // 定义了该接口所属的包名用于Java的包管理
import com.macro.mall.model.SmsFlashPromotionLog; // 导入了SmsFlashPromotionLog实体类用于数据库表的映射
import com.macro.mall.model.SmsFlashPromotionLogExample; // 导入了SmsFlashPromotionLogExample类用于构建查询条件
import java.util.List; // 导入了List接口用于存储查询结果集
import org.apache.ibatis.annotations.Param; // 导入了MyBatis的Param注解用于指定参数名称
public interface SmsFlashPromotionLogMapper { // 声明了一个MyBatis的Mapper接口用于数据库操作
// 以下方法都是MyBatis映射的方法用于数据库的CRUD操作
long countByExample(SmsFlashPromotionLogExample example); // 根据example条件统计记录数
int deleteByExample(SmsFlashPromotionLogExample example); // 根据example条件删除记录
int deleteByPrimaryKey(Integer id); // 根据主键id删除记录这里使用的是Integer类型
int insert(SmsFlashPromotionLog record); // 插入一条SmsFlashPromotionLog记录
int insertSelective(SmsFlashPromotionLog record); // 插入一条SmsFlashPromotionLog记录只插入不为null的字段
List<SmsFlashPromotionLog> selectByExample(SmsFlashPromotionLogExample example); // 根据example条件查询SmsFlashPromotionLog记录
SmsFlashPromotionLog selectByPrimaryKey(Integer id); // 根据主键id查询SmsFlashPromotionLog记录这里使用的是Integer类型
int updateByExampleSelective(@Param("record") SmsFlashPromotionLog record, @Param("example") SmsFlashPromotionLogExample example); // 根据example条件更新SmsFlashPromotionLog记录只更新不为null的字段
int updateByExample(@Param("record") SmsFlashPromotionLog record, @Param("example") SmsFlashPromotionLogExample example); // 根据example条件更新SmsFlashPromotionLog记录
int updateByPrimaryKeySelective(SmsFlashPromotionLog record); // 根据主键id更新SmsFlashPromotionLog记录只更新不为null的字段
int updateByPrimaryKey(SmsFlashPromotionLog record); // 根据主键id更新SmsFlashPromotionLog记录
}

@ -1,32 +0,0 @@
package com.macro.mall.mapper; // 定义了该接口所属的包名用于Java的包管理
import com.macro.mall.model.SmsFlashPromotion; // 导入了SmsFlashPromotion实体类用于数据库表的映射
import com.macro.mall.model.SmsFlashPromotionExample; // 导入了SmsFlashPromotionExample类用于构建查询条件
import java.util.List; // 导入了List接口用于存储查询结果集
import org.apache.ibatis.annotations.Param; // 导入了MyBatis的Param注解用于指定参数名称
public interface SmsFlashPromotionMapper { // 声明了一个MyBatis的Mapper接口用于数据库操作
// 以下方法都是MyBatis映射的方法用于数据库的CRUD操作
long countByExample(SmsFlashPromotionExample example); // 根据example条件统计记录数
int deleteByExample(SmsFlashPromotionExample example); // 根据example条件删除记录
int deleteByPrimaryKey(Long id); // 根据主键id删除记录
int insert(SmsFlashPromotion record); // 插入一条SmsFlashPromotion记录
int insertSelective(SmsFlashPromotion record); // 插入一条SmsFlashPromotion记录只插入不为null的字段
List<SmsFlashPromotion> selectByExample(SmsFlashPromotionExample example); // 根据example条件查询SmsFlashPromotion记录
SmsFlashPromotion selectByPrimaryKey(Long id); // 根据主键id查询SmsFlashPromotion记录
int updateByExampleSelective(@Param("record") SmsFlashPromotion record, @Param("example") SmsFlashPromotionExample example); // 根据example条件更新SmsFlashPromotion记录只更新不为null的字段
int updateByExample(@Param("record") SmsFlashPromotion record, @Param("example") SmsFlashPromotionExample example); // 根据example条件更新SmsFlashPromotion记录
int updateByPrimaryKeySelective(SmsFlashPromotion record); // 根据主键id更新SmsFlashPromotion记录只更新不为null的字段
int updateByPrimaryKey(SmsFlashPromotion record); // 根据主键id更新SmsFlashPromotion记录
}

@ -1,32 +0,0 @@
package com.macro.mall.mapper; // 定义了该接口所属的包名用于Java的包管理
import com.macro.mall.model.SmsFlashPromotionProductRelation; // 导入了SmsFlashPromotionProductRelation实体类用于数据库表的映射
import com.macro.mall.model.SmsFlashPromotionProductRelationExample; // 导入了SmsFlashPromotionProductRelationExample类用于构建查询条件
import java.util.List; // 导入了List接口用于存储查询结果集
import org.apache.ibatis.annotations.Param; // 导入了MyBatis的Param注解用于指定参数名称
public interface SmsFlashPromotionProductRelationMapper { // 声明了一个MyBatis的Mapper接口用于数据库操作
// 以下方法都是MyBatis映射的方法用于数据库的CRUD操作
long countByExample(SmsFlashPromotionProductRelationExample example); // 根据example条件统计记录数
int deleteByExample(SmsFlashPromotionProductRelationExample example); // 根据example条件删除记录
int deleteByPrimaryKey(Long id); // 根据主键id删除记录
int insert(SmsFlashPromotionProductRelation record); // 插入一条SmsFlashPromotionProductRelation记录
int insertSelective(SmsFlashPromotionProductRelation record); // 插入一条SmsFlashPromotionProductRelation记录只插入不为null的字段
List<SmsFlashPromotionProductRelation> selectByExample(SmsFlashPromotionProductRelationExample example); // 根据example条件查询SmsFlashPromotionProductRelation记录
SmsFlashPromotionProductRelation selectByPrimaryKey(Long id); // 根据主键id查询SmsFlashPromotionProductRelation记录
int updateByExampleSelective(@Param("record") SmsFlashPromotionProductRelation record, @Param("example") SmsFlashPromotionProductRelationExample example); // 根据example条件更新SmsFlashPromotionProductRelation记录只更新不为null的字段
int updateByExample(@Param("record") SmsFlashPromotionProductRelation record, @Param("example") SmsFlashPromotionProductRelationExample example); // 根据example条件更新SmsFlashPromotionProductRelation记录
int updateByPrimaryKeySelective(SmsFlashPromotionProductRelation record); // 根据主键id更新SmsFlashPromotionProductRelation记录只更新不为null的字段
int updateByPrimaryKey(SmsFlashPromotionProductRelation record); // 根据主键id更新SmsFlashPromotionProductRelation记录
}

@ -1,32 +0,0 @@
package com.macro.mall.mapper; // 定义了该接口所属的包名用于Java的包管理
import com.macro.mall.model.SmsFlashPromotionSession; // 导入了SmsFlashPromotionSession实体类用于数据库表的映射
import com.macro.mall.model.SmsFlashPromotionSessionExample; // 导入了SmsFlashPromotionSessionExample类用于构建查询条件
import java.util.List; // 导入了List接口用于存储查询结果集
import org.apache.ibatis.annotations.Param; // 导入了MyBatis的Param注解用于指定参数名称
public interface SmsFlashPromotionSessionMapper { // 声明了一个MyBatis的Mapper接口用于数据库操作
// 以下方法都是MyBatis映射的方法用于数据库的CRUD操作
long countByExample(SmsFlashPromotionSessionExample example); // 根据example条件统计记录数
int deleteByExample(SmsFlashPromotionSessionExample example); // 根据example条件删除记录
int deleteByPrimaryKey(Long id); // 根据主键id删除记录
int insert(SmsFlashPromotionSession record); // 插入一条SmsFlashPromotionSession记录
int insertSelective(SmsFlashPromotionSession record); // 插入一条SmsFlashPromotionSession记录只插入不为null的字段
List<SmsFlashPromotionSession> selectByExample(SmsFlashPromotionSessionExample example); // 根据example条件查询SmsFlashPromotionSession记录
SmsFlashPromotionSession selectByPrimaryKey(Long id); // 根据主键id查询SmsFlashPromotionSession记录
int updateByExampleSelective(@Param("record") SmsFlashPromotionSession record, @Param("example") SmsFlashPromotionSessionExample example); // 根据example条件更新SmsFlashPromotionSession记录只更新不为null的字段
int updateByExample(@Param("record") SmsFlashPromotionSession record, @Param("example") SmsFlashPromotionSessionExample example); // 根据example条件更新SmsFlashPromotionSession记录
int updateByPrimaryKeySelective(SmsFlashPromotionSession record); // 根据主键id更新SmsFlashPromotionSession记录只更新不为null的字段
int updateByPrimaryKey(SmsFlashPromotionSession record); // 根据主键id更新SmsFlashPromotionSession记录
}

@ -1,32 +0,0 @@
package com.macro.mall.mapper; // 定义了该接口所属的包名用于Java的包管理
import com.macro.mall.model.SmsHomeAdvertise; // 导入了SmsHomeAdvertise实体类用于数据库表的映射
import com.macro.mall.model.SmsHomeAdvertiseExample; // 导入了SmsHomeAdvertiseExample类用于构建查询条件
import java.util.List; // 导入了List接口用于存储查询结果集
import org.apache.ibatis.annotations.Param; // 导入了MyBatis的Param注解用于指定参数名称
public interface SmsHomeAdvertiseMapper { // 声明了一个MyBatis的Mapper接口用于数据库操作
// 以下方法都是MyBatis映射的方法用于数据库的CRUD操作
long countByExample(SmsHomeAdvertiseExample example); // 根据example条件统计记录数
int deleteByExample(SmsHomeAdvertiseExample example); // 根据example条件删除记录
int deleteByPrimaryKey(Long id); // 根据主键id删除记录
int insert(SmsHomeAdvertise record); // 插入一条SmsHomeAdvertise记录
int insertSelective(SmsHomeAdvertise record); // 插入一条SmsHomeAdvertise记录只插入不为null的字段
List<SmsHomeAdvertise> selectByExample(SmsHomeAdvertiseExample example); // 根据example条件查询SmsHomeAdvertise记录
SmsHomeAdvertise selectByPrimaryKey(Long id); // 根据主键id查询SmsHomeAdvertise记录
int updateByExampleSelective(@Param("record") SmsHomeAdvertise record, @Param("example") SmsHomeAdvertiseExample example); // 根据example条件更新SmsHomeAdvertise记录只更新不为null的字段
int updateByExample(@Param("record") SmsHomeAdvertise record, @Param("example") SmsHomeAdvertiseExample example); // 根据example条件更新SmsHomeAdvertise记录
int updateByPrimaryKeySelective(SmsHomeAdvertise record); // 根据主键id更新SmsHomeAdvertise记录只更新不为null的字段
int updateByPrimaryKey(SmsHomeAdvertise record); // 根据主键id更新SmsHomeAdvertise记录
}

@ -1,32 +0,0 @@
package com.macro.mall.mapper; // 定义了该接口所属的包名用于Java的包管理
import com.macro.mall.model.SmsHomeBrand; // 导入了SmsHomeBrand实体类用于数据库表的映射
import com.macro.mall.model.SmsHomeBrandExample; // 导入了SmsHomeBrandExample类用于构建查询条件
import java.util.List; // 导入了List接口用于存储查询结果集
import org.apache.ibatis.annotations.Param; // 导入了MyBatis的Param注解用于指定参数名称
public interface SmsHomeBrandMapper { // 声明了一个MyBatis的Mapper接口用于数据库操作
// 以下方法都是MyBatis映射的方法用于数据库的CRUD操作
long countByExample(SmsHomeBrandExample example); // 根据example条件统计记录数
int deleteByExample(SmsHomeBrandExample example); // 根据example条件删除记录
int deleteByPrimaryKey(Long id); // 根据主键id删除记录
int insert(SmsHomeBrand record); // 插入一条SmsHomeBrand记录
int insertSelective(SmsHomeBrand record); // 插入一条SmsHomeBrand记录只插入不为null的字段
List<SmsHomeBrand> selectByExample(SmsHomeBrandExample example); // 根据example条件查询SmsHomeBrand记录
SmsHomeBrand selectByPrimaryKey(Long id); // 根据主键id查询SmsHomeBrand记录
int updateByExampleSelective(@Param("record") SmsHomeBrand record, @Param("example") SmsHomeBrandExample example); // 根据example条件更新SmsHomeBrand记录只更新不为null的字段
int updateByExample(@Param("record") SmsHomeBrand record, @Param("example") SmsHomeBrandExample example); // 根据example条件更新SmsHomeBrand记录
int updateByPrimaryKeySelective(SmsHomeBrand record); // 根据主键id更新SmsHomeBrand记录只更新不为null的字段
int updateByPrimaryKey(SmsHomeBrand record); // 根据主键id更新SmsHomeBrand记录
}

@ -1,32 +0,0 @@
package com.macro.mall.mapper; // 定义了该接口所属的包名用于Java的包管理
import com.macro.mall.model.SmsHomeNewProduct; // 导入了SmsHomeNewProduct实体类用于数据库表的映射
import com.macro.mall.model.SmsHomeNewProductExample; // 导入了SmsHomeNewProductExample类用于构建查询条件
import java.util.List; // 导入了List接口用于存储查询结果集
import org.apache.ibatis.annotations.Param; // 导入了MyBatis的Param注解用于指定参数名称
public interface SmsHomeNewProductMapper { // 声明了一个MyBatis的Mapper接口用于数据库操作
// 以下方法都是MyBatis映射的方法用于数据库的CRUD操作
long countByExample(SmsHomeNewProductExample example); // 根据example条件统计记录数
int deleteByExample(SmsHomeNewProductExample example); // 根据example条件删除记录
int deleteByPrimaryKey(Long id); // 根据主键id删除记录
int insert(SmsHomeNewProduct record); // 插入一条SmsHomeNewProduct记录
int insertSelective(SmsHomeNewProduct record); // 插入一条SmsHomeNewProduct记录只插入不为null的字段
List<SmsHomeNewProduct> selectByExample(SmsHomeNewProductExample example); // 根据example条件查询SmsHomeNewProduct记录
SmsHomeNewProduct selectByPrimaryKey(Long id); // 根据主键id查询SmsHomeNewProduct记录
int updateByExampleSelective(@Param("record") SmsHomeNewProduct record, @Param("example") SmsHomeNewProductExample example); // 根据example条件更新SmsHomeNewProduct记录只更新不为null的字段
int updateByExample(@Param("record") SmsHomeNewProduct record, @Param("example") SmsHomeNewProductExample example); // 根据example条件更新SmsHomeNewProduct记录
int updateByPrimaryKeySelective(SmsHomeNewProduct record); // 根据主键id更新SmsHomeNewProduct记录只更新不为null的字段
int updateByPrimaryKey(SmsHomeNewProduct record); // 根据主键id更新SmsHomeNewProduct记录
}

@ -1,32 +0,0 @@
package com.macro.mall.mapper; // 定义了该接口所属的包名用于Java的包管理
import com.macro.mall.model.SmsHomeRecommendProduct; // 导入了SmsHomeRecommendProduct实体类用于数据库表的映射
import com.macro.mall.model.SmsHomeRecommendProductExample; // 导入了SmsHomeRecommendProductExample类用于构建查询条件
import java.util.List; // 导入了List接口用于存储查询结果集
import org.apache.ibatis.annotations.Param; // 导入了MyBatis的Param注解用于指定参数名称
public interface SmsHomeRecommendProductMapper { // 声明了一个MyBatis的Mapper接口用于数据库操作
// 以下方法都是MyBatis映射的方法用于数据库的CRUD操作
long countByExample(SmsHomeRecommendProductExample example); // 根据example条件统计记录数
int deleteByExample(SmsHomeRecommendProductExample example); // 根据example条件删除记录
int deleteByPrimaryKey(Long id); // 根据主键id删除记录
int insert(SmsHomeRecommendProduct record); // 插入一条SmsHomeRecommendProduct记录
int insertSelective(SmsHomeRecommendProduct record); // 插入一条SmsHomeRecommendProduct记录只插入不为null的字段
List<SmsHomeRecommendProduct> selectByExample(SmsHomeRecommendProductExample example); // 根据example条件查询SmsHomeRecommendProduct记录
SmsHomeRecommendProduct selectByPrimaryKey(Long id); // 根据主键id查询SmsHomeRecommendProduct记录
int updateByExampleSelective(@Param("record") SmsHomeRecommendProduct record, @Param("example") SmsHomeRecommendProductExample example); // 根据example条件更新SmsHomeRecommendProduct记录只更新不为null的字段
int updateByExample(@Param("record") SmsHomeRecommendProduct record, @Param("example") SmsHomeRecommendProductExample example); // 根据example条件更新SmsHomeRecommendProduct记录
int updateByPrimaryKeySelective(SmsHomeRecommendProduct record); // 根据主键id更新SmsHomeRecommendProduct记录只更新不为null的字段
int updateByPrimaryKey(SmsHomeRecommendProduct record); // 根据主键id更新SmsHomeRecommendProduct记录
}

@ -1,32 +0,0 @@
package com.macro.mall.mapper; // 定义了该接口所属的包名用于Java的包管理
import com.macro.mall.model.SmsHomeRecommendSubject; // 导入了SmsHomeRecommendSubject实体类用于数据库表的映射
import com.macro.mall.model.SmsHomeRecommendSubjectExample; // 导入了SmsHomeRecommendSubjectExample类用于构建查询条件
import java.util.List; // 导入了List接口用于存储查询结果集
import org.apache.ibatis.annotations.Param; // 导入了MyBatis的Param注解用于指定参数名称
public interface SmsHomeRecommendSubjectMapper { // 声明了一个MyBatis的Mapper接口用于数据库操作
// 以下方法都是MyBatis映射的方法用于数据库的CRUD操作
long countByExample(SmsHomeRecommendSubjectExample example); // 根据example条件统计记录数
int deleteByExample(SmsHomeRecommendSubjectExample example); // 根据example条件删除记录
int deleteByPrimaryKey(Long id); // 根据主键id删除记录
int insert(SmsHomeRecommendSubject record); // 插入一条SmsHomeRecommendSubject记录
int insertSelective(SmsHomeRecommendSubject record); // 插入一条SmsHomeRecommendSubject记录只插入不为null的字段
List<SmsHomeRecommendSubject> selectByExample(SmsHomeRecommendSubjectExample example); // 根据example条件查询SmsHomeRecommendSubject记录
SmsHomeRecommendSubject selectByPrimaryKey(Long id); // 根据主键id查询SmsHomeRecommendSubject记录
int updateByExampleSelective(@Param("record") SmsHomeRecommendSubject record, @Param("example") SmsHomeRecommendSubjectExample example); // 根据example条件更新SmsHomeRecommendSubject记录只更新不为null的字段
int updateByExample(@Param("record") SmsHomeRecommendSubject record, @Param("example") SmsHomeRecommendSubjectExample example); // 根据example条件更新SmsHomeRecommendSubject记录
int updateByPrimaryKeySelective(SmsHomeRecommendSubject record); // 根据主键id更新SmsHomeRecommendSubject记录只更新不为null的字段
int updateByPrimaryKey(SmsHomeRecommendSubject record); // 根据主键id更新SmsHomeRecommendSubject记录
}

@ -1,32 +0,0 @@
package com.macro.mall.mapper; // 定义了该接口所属的包名用于Java的包管理
import com.macro.mall.model.UmsAdminLoginLog; // 导入了UmsAdminLoginLog实体类用于数据库表的映射
import com.macro.mall.model.UmsAdminLoginLogExample; // 导入了UmsAdminLoginLogExample类用于构建查询条件
import java.util.List; // 导入了List接口用于存储查询结果集
import org.apache.ibatis.annotations.Param; // 导入了MyBatis的Param注解用于指定参数名称
public interface UmsAdminLoginLogMapper { // 声明了一个MyBatis的Mapper接口用于数据库操作
// 以下方法都是MyBatis映射的方法用于数据库的CRUD操作
long countByExample(UmsAdminLoginLogExample example); // 根据example条件统计记录数
int deleteByExample(UmsAdminLoginLogExample example); // 根据example条件删除记录
int deleteByPrimaryKey(Long id); // 根据主键id删除记录
int insert(UmsAdminLoginLog record); // 插入一条UmsAdminLoginLog记录
int insertSelective(UmsAdminLoginLog record); // 插入一条UmsAdminLoginLog记录只插入不为null的字段
List<UmsAdminLoginLog> selectByExample(UmsAdminLoginLogExample example); // 根据example条件查询UmsAdminLoginLog记录
UmsAdminLoginLog selectByPrimaryKey(Long id); // 根据主键id查询UmsAdminLoginLog记录
int updateByExampleSelective(@Param("record") UmsAdminLoginLog record, @Param("example") UmsAdminLoginLogExample example); // 根据example条件更新UmsAdminLoginLog记录只更新不为null的字段
int updateByExample(@Param("record") UmsAdminLoginLog record, @Param("example") UmsAdminLoginLogExample example); // 根据example条件更新UmsAdminLoginLog记录
int updateByPrimaryKeySelective(UmsAdminLoginLog record); // 根据主键id更新UmsAdminLoginLog记录只更新不为null的字段
int updateByPrimaryKey(UmsAdminLoginLog record); // 根据主键id更新UmsAdminLoginLog记录
}

@ -1,32 +0,0 @@
package com.macro.mall.mapper; // 定义了该接口所属的包名用于Java的包管理
import com.macro.mall.model.UmsAdmin; // 导入了UmsAdmin实体类用于数据库表的映射
import com.macro.mall.model.UmsAdminExample; // 导入了UmsAdminExample类用于构建查询条件
import java.util.List; // 导入了List接口用于存储查询结果集
import org.apache.ibatis.annotations.Param; // 导入了MyBatis的Param注解用于指定参数名称
public interface UmsAdminMapper { // 声明了一个MyBatis的Mapper接口用于数据库操作
// 以下方法都是MyBatis映射的方法用于数据库的CRUD操作
long countByExample(UmsAdminExample example); // 根据example条件统计记录数
int deleteByExample(UmsAdminExample example); // 根据example条件删除记录
int deleteByPrimaryKey(Long id); // 根据主键id删除记录
int insert(UmsAdmin record); // 插入一条UmsAdmin记录
int insertSelective(UmsAdmin record); // 插入一条UmsAdmin记录只插入不为null的字段
List<UmsAdmin> selectByExample(UmsAdminExample example); // 根据example条件查询UmsAdmin记录
UmsAdmin selectByPrimaryKey(Long id); // 根据主键id查询UmsAdmin记录
int updateByExampleSelective(@Param("record") UmsAdmin record, @Param("example") UmsAdminExample example); // 根据example条件更新UmsAdmin记录只更新不为null的字段
int updateByExample(@Param("record") UmsAdmin record, @Param("example") UmsAdminExample example); // 根据example条件更新UmsAdmin记录
int updateByPrimaryKeySelective(UmsAdmin record); // 根据主键id更新UmsAdmin记录只更新不为null的字段
int updateByPrimaryKey(UmsAdmin record); // 根据主键id更新UmsAdmin记录
}

@ -1,32 +0,0 @@
package com.macro.mall.mapper; // 定义了该接口所属的包名用于Java的包管理
import com.macro.mall.model.UmsAdminPermissionRelation; // 导入了UmsAdminPermissionRelation实体类用于数据库表的映射
import com.macro.mall.model.UmsAdminPermissionRelationExample; // 导入了UmsAdminPermissionRelationExample类用于构建查询条件
import java.util.List; // 导入了List接口用于存储查询结果集
import org.apache.ibatis.annotations.Param; // 导入了MyBatis的Param注解用于指定参数名称
public interface UmsAdminPermissionRelationMapper { // 声明了一个MyBatis的Mapper接口用于数据库操作
// 以下方法都是MyBatis映射的方法用于数据库的CRUD操作
long countByExample(UmsAdminPermissionRelationExample example); // 根据example条件统计记录数
int deleteByExample(UmsAdminPermissionRelationExample example); // 根据example条件删除记录
int deleteByPrimaryKey(Long id); // 根据主键id删除记录
int insert(UmsAdminPermissionRelation record); // 插入一条UmsAdminPermissionRelation记录
int insertSelective(UmsAdminPermissionRelation record); // 插入一条UmsAdminPermissionRelation记录只插入不为null的字段
List<UmsAdminPermissionRelation> selectByExample(UmsAdminPermissionRelationExample example); // 根据example条件查询UmsAdminPermissionRelation记录
UmsAdminPermissionRelation selectByPrimaryKey(Long id); // 根据主键id查询UmsAdminPermissionRelation记录
int updateByExampleSelective(@Param("record") UmsAdminPermissionRelation record, @Param("example") UmsAdminPermissionRelationExample example); // 根据example条件更新UmsAdminPermissionRelation记录只更新不为null的字段
int updateByExample(@Param("record") UmsAdminPermissionRelation record, @Param("example") UmsAdminPermissionRelationExample example); // 根据example条件更新UmsAdminPermissionRelation记录
int updateByPrimaryKeySelective(UmsAdminPermissionRelation record); // 根据主键id更新UmsAdminPermissionRelation记录只更新不为null的字段
int updateByPrimaryKey(UmsAdminPermissionRelation record); // 根据主键id更新UmsAdminPermissionRelation记录
}

@ -1,32 +0,0 @@
package com.macro.mall.mapper; // 定义了该接口所属的包名用于Java的包管理
import com.macro.mall.model.UmsAdminRoleRelation; // 导入了UmsAdminRoleRelation实体类用于数据库表的映射
import com.macro.mall.model.UmsAdminRoleRelationExample; // 导入了UmsAdminRoleRelationExample类用于构建查询条件
import java.util.List; // 导入了List接口用于存储查询结果集
import org.apache.ibatis.annotations.Param; // 导入了MyBatis的Param注解用于指定参数名称
public interface UmsAdminRoleRelationMapper { // 声明了一个MyBatis的Mapper接口用于数据库操作
// 以下方法都是MyBatis映射的方法用于数据库的CRUD操作
long countByExample(UmsAdminRoleRelationExample example); // 根据example条件统计记录数
int deleteByExample(UmsAdminRoleRelationExample example); // 根据example条件删除记录
int deleteByPrimaryKey(Long id); // 根据主键id删除记录
int insert(UmsAdminRoleRelation record); // 插入一条UmsAdminRoleRelation记录
int insertSelective(UmsAdminRoleRelation record); // 插入一条UmsAdminRoleRelation记录只插入不为null的字段
List<UmsAdminRoleRelation> selectByExample(UmsAdminRoleRelationExample example); // 根据example条件查询UmsAdminRoleRelation记录
UmsAdminRoleRelation selectByPrimaryKey(Long id); // 根据主键id查询UmsAdminRoleRelation记录
int updateByExampleSelective(@Param("record") UmsAdminRoleRelation record, @Param("example") UmsAdminRoleRelationExample example); // 根据example条件更新UmsAdminRoleRelation记录只更新不为null的字段
int updateByExample(@Param("record") UmsAdminRoleRelation record, @Param("example") UmsAdminRoleRelationExample example); // 根据example条件更新UmsAdminRoleRelation记录
int updateByPrimaryKeySelective(UmsAdminRoleRelation record); // 根据主键id更新UmsAdminRoleRelation记录只更新不为null的字段
int updateByPrimaryKey(UmsAdminRoleRelation record); // 根据主键id更新UmsAdminRoleRelation记录
}

@ -1,32 +0,0 @@
package com.macro.mall.mapper; // 定义了该接口所属的包名用于Java的包管理
import com.macro.mall.model.UmsGrowthChangeHistory; // 导入了UmsGrowthChangeHistory实体类用于数据库表的映射
import com.macro.mall.model.UmsGrowthChangeHistoryExample; // 导入了UmsGrowthChangeHistoryExample类用于构建查询条件
import java.util.List; // 导入了List接口用于存储查询结果集
import org.apache.ibatis.annotations.Param; // 导入了MyBatis的Param注解用于指定参数名称
public interface UmsGrowthChangeHistoryMapper { // 声明了一个MyBatis的Mapper接口用于数据库操作
// 以下方法都是MyBatis映射的方法用于数据库的CRUD操作
long countByExample(UmsGrowthChangeHistoryExample example); // 根据example条件统计记录数
int deleteByExample(UmsGrowthChangeHistoryExample example); // 根据example条件删除记录
int deleteByPrimaryKey(Long id); // 根据主键id删除记录
int insert(UmsGrowthChangeHistory record); // 插入一条UmsGrowthChangeHistory记录
int insertSelective(UmsGrowthChangeHistory record); // 插入一条UmsGrowthChangeHistory记录只插入不为null的字段
List<UmsGrowthChangeHistory> selectByExample(UmsGrowthChangeHistoryExample example); // 根据example条件查询UmsGrowthChangeHistory记录
UmsGrowthChangeHistory selectByPrimaryKey(Long id); // 根据主键id查询UmsGrowthChangeHistory记录
int updateByExampleSelective(@Param("record") UmsGrowthChangeHistory record, @Param("example") UmsGrowthChangeHistoryExample example); // 根据example条件更新UmsGrowthChangeHistory记录只更新不为null的字段
int updateByExample(@Param("record") UmsGrowthChangeHistory record, @Param("example") UmsGrowthChangeHistoryExample example); // 根据example条件更新UmsGrowthChangeHistory记录
int updateByPrimaryKeySelective(UmsGrowthChangeHistory record); // 根据主键id更新UmsGrowthChangeHistory记录只更新不为null的字段
int updateByPrimaryKey(UmsGrowthChangeHistory record); // 根据主键id更新UmsGrowthChangeHistory记录
}

@ -1,32 +0,0 @@
package com.macro.mall.mapper; // 定义了该接口所属的包名用于Java的包管理
import com.macro.mall.model.UmsIntegrationChangeHistory; // 导入了UmsIntegrationChangeHistory实体类用于数据库表的映射
import com.macro.mall.model.UmsIntegrationChangeHistoryExample; // 导入了UmsIntegrationChangeHistoryExample类用于构建查询条件
import java.util.List; // 导入了List接口用于存储查询结果集
import org.apache.ibatis.annotations.Param; // 导入了MyBatis的Param注解用于指定参数名称
public interface UmsIntegrationChangeHistoryMapper { // 声明了一个MyBatis的Mapper接口用于数据库操作
// 以下方法都是MyBatis映射的方法用于数据库的CRUD操作
long countByExample(UmsIntegrationChangeHistoryExample example); // 根据example条件统计记录数
int deleteByExample(UmsIntegrationChangeHistoryExample example); // 根据example条件删除记录
int deleteByPrimaryKey(Long id); // 根据主键id删除记录
int insert(UmsIntegrationChangeHistory record); // 插入一条UmsIntegrationChangeHistory记录
int insertSelective(UmsIntegrationChangeHistory record); // 插入一条UmsIntegrationChangeHistory记录只插入不为null的字段
List<UmsIntegrationChangeHistory> selectByExample(UmsIntegrationChangeHistoryExample example); // 根据example条件查询UmsIntegrationChangeHistory记录
UmsIntegrationChangeHistory selectByPrimaryKey(Long id); // 根据主键id查询UmsIntegrationChangeHistory记录
int updateByExampleSelective(@Param("record") UmsIntegrationChangeHistory record, @Param("example") UmsIntegrationChangeHistoryExample example); // 根据example条件更新UmsIntegrationChangeHistory记录只更新不为null的字段
int updateByExample(@Param("record") UmsIntegrationChangeHistory record, @Param("example") UmsIntegrationChangeHistoryExample example); // 根据example条件更新UmsIntegrationChangeHistory记录
int updateByPrimaryKeySelective(UmsIntegrationChangeHistory record); // 根据主键id更新UmsIntegrationChangeHistory记录只更新不为null的字段
int updateByPrimaryKey(UmsIntegrationChangeHistory record); // 根据主键id更新UmsIntegrationChangeHistory记录
}

@ -1,30 +0,0 @@
package com.macro.mall.mapper;
import com.macro.mall.model.UmsIntegrationConsumeSetting;
import com.macro.mall.model.UmsIntegrationConsumeSettingExample;
import java.util.List;
import org.apache.ibatis.annotations.Param;
public interface UmsIntegrationConsumeSettingMapper {
long countByExample(UmsIntegrationConsumeSettingExample example);
int deleteByExample(UmsIntegrationConsumeSettingExample example);
int deleteByPrimaryKey(Long id);
int insert(UmsIntegrationConsumeSetting record);
int insertSelective(UmsIntegrationConsumeSetting record);
List<UmsIntegrationConsumeSetting> selectByExample(UmsIntegrationConsumeSettingExample example);
UmsIntegrationConsumeSetting selectByPrimaryKey(Long id);
int updateByExampleSelective(@Param("record") UmsIntegrationConsumeSetting record, @Param("example") UmsIntegrationConsumeSettingExample example);
int updateByExample(@Param("record") UmsIntegrationConsumeSetting record, @Param("example") UmsIntegrationConsumeSettingExample example);
int updateByPrimaryKeySelective(UmsIntegrationConsumeSetting record);
int updateByPrimaryKey(UmsIntegrationConsumeSetting record);
}

@ -1,30 +0,0 @@
package com.macro.mall.mapper;
import com.macro.mall.model.UmsMemberLevel;
import com.macro.mall.model.UmsMemberLevelExample;
import java.util.List;
import org.apache.ibatis.annotations.Param;
public interface UmsMemberLevelMapper {
long countByExample(UmsMemberLevelExample example);
int deleteByExample(UmsMemberLevelExample example);
int deleteByPrimaryKey(Long id);
int insert(UmsMemberLevel record);
int insertSelective(UmsMemberLevel record);
List<UmsMemberLevel> selectByExample(UmsMemberLevelExample example);
UmsMemberLevel selectByPrimaryKey(Long id);
int updateByExampleSelective(@Param("record") UmsMemberLevel record, @Param("example") UmsMemberLevelExample example);
int updateByExample(@Param("record") UmsMemberLevel record, @Param("example") UmsMemberLevelExample example);
int updateByPrimaryKeySelective(UmsMemberLevel record);
int updateByPrimaryKey(UmsMemberLevel record);
}

@ -1,30 +0,0 @@
package com.macro.mall.mapper;
import com.macro.mall.model.UmsMemberLoginLog;
import com.macro.mall.model.UmsMemberLoginLogExample;
import java.util.List;
import org.apache.ibatis.annotations.Param;
public interface UmsMemberLoginLogMapper {
long countByExample(UmsMemberLoginLogExample example);
int deleteByExample(UmsMemberLoginLogExample example);
int deleteByPrimaryKey(Long id);
int insert(UmsMemberLoginLog record);
int insertSelective(UmsMemberLoginLog record);
List<UmsMemberLoginLog> selectByExample(UmsMemberLoginLogExample example);
UmsMemberLoginLog selectByPrimaryKey(Long id);
int updateByExampleSelective(@Param("record") UmsMemberLoginLog record, @Param("example") UmsMemberLoginLogExample example);
int updateByExample(@Param("record") UmsMemberLoginLog record, @Param("example") UmsMemberLoginLogExample example);
int updateByPrimaryKeySelective(UmsMemberLoginLog record);
int updateByPrimaryKey(UmsMemberLoginLog record);
}

@ -1,30 +0,0 @@
package com.macro.mall.mapper;
import com.macro.mall.model.UmsMember;
import com.macro.mall.model.UmsMemberExample;
import java.util.List;
import org.apache.ibatis.annotations.Param;
public interface UmsMemberMapper {
long countByExample(UmsMemberExample example);
int deleteByExample(UmsMemberExample example);
int deleteByPrimaryKey(Long id);
int insert(UmsMember record);
int insertSelective(UmsMember record);
List<UmsMember> selectByExample(UmsMemberExample example);
UmsMember selectByPrimaryKey(Long id);
int updateByExampleSelective(@Param("record") UmsMember record, @Param("example") UmsMemberExample example);
int updateByExample(@Param("record") UmsMember record, @Param("example") UmsMemberExample example);
int updateByPrimaryKeySelective(UmsMember record);
int updateByPrimaryKey(UmsMember record);
}

@ -1,30 +0,0 @@
package com.macro.mall.mapper;
import com.macro.mall.model.UmsMemberMemberTagRelation;
import com.macro.mall.model.UmsMemberMemberTagRelationExample;
import java.util.List;
import org.apache.ibatis.annotations.Param;
public interface UmsMemberMemberTagRelationMapper {
long countByExample(UmsMemberMemberTagRelationExample example);
int deleteByExample(UmsMemberMemberTagRelationExample example);
int deleteByPrimaryKey(Long id);
int insert(UmsMemberMemberTagRelation record);
int insertSelective(UmsMemberMemberTagRelation record);
List<UmsMemberMemberTagRelation> selectByExample(UmsMemberMemberTagRelationExample example);
UmsMemberMemberTagRelation selectByPrimaryKey(Long id);
int updateByExampleSelective(@Param("record") UmsMemberMemberTagRelation record, @Param("example") UmsMemberMemberTagRelationExample example);
int updateByExample(@Param("record") UmsMemberMemberTagRelation record, @Param("example") UmsMemberMemberTagRelationExample example);
int updateByPrimaryKeySelective(UmsMemberMemberTagRelation record);
int updateByPrimaryKey(UmsMemberMemberTagRelation record);
}

@ -1,30 +0,0 @@
package com.macro.mall.mapper;
import com.macro.mall.model.UmsMemberProductCategoryRelation;
import com.macro.mall.model.UmsMemberProductCategoryRelationExample;
import java.util.List;
import org.apache.ibatis.annotations.Param;
public interface UmsMemberProductCategoryRelationMapper {
long countByExample(UmsMemberProductCategoryRelationExample example);
int deleteByExample(UmsMemberProductCategoryRelationExample example);
int deleteByPrimaryKey(Long id);
int insert(UmsMemberProductCategoryRelation record);
int insertSelective(UmsMemberProductCategoryRelation record);
List<UmsMemberProductCategoryRelation> selectByExample(UmsMemberProductCategoryRelationExample example);
UmsMemberProductCategoryRelation selectByPrimaryKey(Long id);
int updateByExampleSelective(@Param("record") UmsMemberProductCategoryRelation record, @Param("example") UmsMemberProductCategoryRelationExample example);
int updateByExample(@Param("record") UmsMemberProductCategoryRelation record, @Param("example") UmsMemberProductCategoryRelationExample example);
int updateByPrimaryKeySelective(UmsMemberProductCategoryRelation record);
int updateByPrimaryKey(UmsMemberProductCategoryRelation record);
}

@ -1,30 +0,0 @@
package com.macro.mall.mapper;
import com.macro.mall.model.UmsMemberReceiveAddress;
import com.macro.mall.model.UmsMemberReceiveAddressExample;
import java.util.List;
import org.apache.ibatis.annotations.Param;
public interface UmsMemberReceiveAddressMapper {
long countByExample(UmsMemberReceiveAddressExample example);
int deleteByExample(UmsMemberReceiveAddressExample example);
int deleteByPrimaryKey(Long id);
int insert(UmsMemberReceiveAddress record);
int insertSelective(UmsMemberReceiveAddress record);
List<UmsMemberReceiveAddress> selectByExample(UmsMemberReceiveAddressExample example);
UmsMemberReceiveAddress selectByPrimaryKey(Long id);
int updateByExampleSelective(@Param("record") UmsMemberReceiveAddress record, @Param("example") UmsMemberReceiveAddressExample example);
int updateByExample(@Param("record") UmsMemberReceiveAddress record, @Param("example") UmsMemberReceiveAddressExample example);
int updateByPrimaryKeySelective(UmsMemberReceiveAddress record);
int updateByPrimaryKey(UmsMemberReceiveAddress record);
}

@ -1,30 +0,0 @@
package com.macro.mall.mapper;
import com.macro.mall.model.UmsMemberRuleSetting;
import com.macro.mall.model.UmsMemberRuleSettingExample;
import java.util.List;
import org.apache.ibatis.annotations.Param;
public interface UmsMemberRuleSettingMapper {
long countByExample(UmsMemberRuleSettingExample example);
int deleteByExample(UmsMemberRuleSettingExample example);
int deleteByPrimaryKey(Long id);
int insert(UmsMemberRuleSetting record);
int insertSelective(UmsMemberRuleSetting record);
List<UmsMemberRuleSetting> selectByExample(UmsMemberRuleSettingExample example);
UmsMemberRuleSetting selectByPrimaryKey(Long id);
int updateByExampleSelective(@Param("record") UmsMemberRuleSetting record, @Param("example") UmsMemberRuleSettingExample example);
int updateByExample(@Param("record") UmsMemberRuleSetting record, @Param("example") UmsMemberRuleSettingExample example);
int updateByPrimaryKeySelective(UmsMemberRuleSetting record);
int updateByPrimaryKey(UmsMemberRuleSetting record);
}

@ -1,30 +0,0 @@
package com.macro.mall.mapper;
import com.macro.mall.model.UmsMemberStatisticsInfo;
import com.macro.mall.model.UmsMemberStatisticsInfoExample;
import java.util.List;
import org.apache.ibatis.annotations.Param;
public interface UmsMemberStatisticsInfoMapper {
long countByExample(UmsMemberStatisticsInfoExample example);
int deleteByExample(UmsMemberStatisticsInfoExample example);
int deleteByPrimaryKey(Long id);
int insert(UmsMemberStatisticsInfo record);
int insertSelective(UmsMemberStatisticsInfo record);
List<UmsMemberStatisticsInfo> selectByExample(UmsMemberStatisticsInfoExample example);
UmsMemberStatisticsInfo selectByPrimaryKey(Long id);
int updateByExampleSelective(@Param("record") UmsMemberStatisticsInfo record, @Param("example") UmsMemberStatisticsInfoExample example);
int updateByExample(@Param("record") UmsMemberStatisticsInfo record, @Param("example") UmsMemberStatisticsInfoExample example);
int updateByPrimaryKeySelective(UmsMemberStatisticsInfo record);
int updateByPrimaryKey(UmsMemberStatisticsInfo record);
}

@ -1,30 +0,0 @@
package com.macro.mall.mapper;
import com.macro.mall.model.UmsMemberTag;
import com.macro.mall.model.UmsMemberTagExample;
import java.util.List;
import org.apache.ibatis.annotations.Param;
public interface UmsMemberTagMapper {
long countByExample(UmsMemberTagExample example);
int deleteByExample(UmsMemberTagExample example);
int deleteByPrimaryKey(Long id);
int insert(UmsMemberTag record);
int insertSelective(UmsMemberTag record);
List<UmsMemberTag> selectByExample(UmsMemberTagExample example);
UmsMemberTag selectByPrimaryKey(Long id);
int updateByExampleSelective(@Param("record") UmsMemberTag record, @Param("example") UmsMemberTagExample example);
int updateByExample(@Param("record") UmsMemberTag record, @Param("example") UmsMemberTagExample example);
int updateByPrimaryKeySelective(UmsMemberTag record);
int updateByPrimaryKey(UmsMemberTag record);
}

@ -1,30 +0,0 @@
package com.macro.mall.mapper;
import com.macro.mall.model.UmsMemberTask;
import com.macro.mall.model.UmsMemberTaskExample;
import java.util.List;
import org.apache.ibatis.annotations.Param;
public interface UmsMemberTaskMapper {
long countByExample(UmsMemberTaskExample example);
int deleteByExample(UmsMemberTaskExample example);
int deleteByPrimaryKey(Long id);
int insert(UmsMemberTask record);
int insertSelective(UmsMemberTask record);
List<UmsMemberTask> selectByExample(UmsMemberTaskExample example);
UmsMemberTask selectByPrimaryKey(Long id);
int updateByExampleSelective(@Param("record") UmsMemberTask record, @Param("example") UmsMemberTaskExample example);
int updateByExample(@Param("record") UmsMemberTask record, @Param("example") UmsMemberTaskExample example);
int updateByPrimaryKeySelective(UmsMemberTask record);
int updateByPrimaryKey(UmsMemberTask record);
}

@ -1,30 +0,0 @@
package com.macro.mall.mapper;
import com.macro.mall.model.UmsMenu;
import com.macro.mall.model.UmsMenuExample;
import java.util.List;
import org.apache.ibatis.annotations.Param;
public interface UmsMenuMapper {
long countByExample(UmsMenuExample example);
int deleteByExample(UmsMenuExample example);
int deleteByPrimaryKey(Long id);
int insert(UmsMenu record);
int insertSelective(UmsMenu record);
List<UmsMenu> selectByExample(UmsMenuExample example);
UmsMenu selectByPrimaryKey(Long id);
int updateByExampleSelective(@Param("record") UmsMenu record, @Param("example") UmsMenuExample example);
int updateByExample(@Param("record") UmsMenu record, @Param("example") UmsMenuExample example);
int updateByPrimaryKeySelective(UmsMenu record);
int updateByPrimaryKey(UmsMenu record);
}

@ -1,30 +0,0 @@
package com.macro.mall.mapper;
import com.macro.mall.model.UmsPermission;
import com.macro.mall.model.UmsPermissionExample;
import java.util.List;
import org.apache.ibatis.annotations.Param;
public interface UmsPermissionMapper {
long countByExample(UmsPermissionExample example);
int deleteByExample(UmsPermissionExample example);
int deleteByPrimaryKey(Long id);
int insert(UmsPermission record);
int insertSelective(UmsPermission record);
List<UmsPermission> selectByExample(UmsPermissionExample example);
UmsPermission selectByPrimaryKey(Long id);
int updateByExampleSelective(@Param("record") UmsPermission record, @Param("example") UmsPermissionExample example);
int updateByExample(@Param("record") UmsPermission record, @Param("example") UmsPermissionExample example);
int updateByPrimaryKeySelective(UmsPermission record);
int updateByPrimaryKey(UmsPermission record);
}

@ -1,30 +0,0 @@
package com.macro.mall.mapper;
import com.macro.mall.model.UmsResourceCategory;
import com.macro.mall.model.UmsResourceCategoryExample;
import java.util.List;
import org.apache.ibatis.annotations.Param;
public interface UmsResourceCategoryMapper {
long countByExample(UmsResourceCategoryExample example);
int deleteByExample(UmsResourceCategoryExample example);
int deleteByPrimaryKey(Long id);
int insert(UmsResourceCategory record);
int insertSelective(UmsResourceCategory record);
List<UmsResourceCategory> selectByExample(UmsResourceCategoryExample example);
UmsResourceCategory selectByPrimaryKey(Long id);
int updateByExampleSelective(@Param("record") UmsResourceCategory record, @Param("example") UmsResourceCategoryExample example);
int updateByExample(@Param("record") UmsResourceCategory record, @Param("example") UmsResourceCategoryExample example);
int updateByPrimaryKeySelective(UmsResourceCategory record);
int updateByPrimaryKey(UmsResourceCategory record);
}

@ -1,30 +0,0 @@
package com.macro.mall.mapper;
import com.macro.mall.model.UmsResource;
import com.macro.mall.model.UmsResourceExample;
import java.util.List;
import org.apache.ibatis.annotations.Param;
public interface UmsResourceMapper {
long countByExample(UmsResourceExample example);
int deleteByExample(UmsResourceExample example);
int deleteByPrimaryKey(Long id);
int insert(UmsResource record);
int insertSelective(UmsResource record);
List<UmsResource> selectByExample(UmsResourceExample example);
UmsResource selectByPrimaryKey(Long id);
int updateByExampleSelective(@Param("record") UmsResource record, @Param("example") UmsResourceExample example);
int updateByExample(@Param("record") UmsResource record, @Param("example") UmsResourceExample example);
int updateByPrimaryKeySelective(UmsResource record);
int updateByPrimaryKey(UmsResource record);
}

@ -1,30 +0,0 @@
package com.macro.mall.mapper;
import com.macro.mall.model.UmsRole;
import com.macro.mall.model.UmsRoleExample;
import java.util.List;
import org.apache.ibatis.annotations.Param;
public interface UmsRoleMapper {
long countByExample(UmsRoleExample example);
int deleteByExample(UmsRoleExample example);
int deleteByPrimaryKey(Long id);
int insert(UmsRole record);
int insertSelective(UmsRole record);
List<UmsRole> selectByExample(UmsRoleExample example);
UmsRole selectByPrimaryKey(Long id);
int updateByExampleSelective(@Param("record") UmsRole record, @Param("example") UmsRoleExample example);
int updateByExample(@Param("record") UmsRole record, @Param("example") UmsRoleExample example);
int updateByPrimaryKeySelective(UmsRole record);
int updateByPrimaryKey(UmsRole record);
}

@ -1,30 +0,0 @@
package com.macro.mall.mapper;
import com.macro.mall.model.UmsRoleMenuRelation;
import com.macro.mall.model.UmsRoleMenuRelationExample;
import java.util.List;
import org.apache.ibatis.annotations.Param;
public interface UmsRoleMenuRelationMapper {
long countByExample(UmsRoleMenuRelationExample example);
int deleteByExample(UmsRoleMenuRelationExample example);
int deleteByPrimaryKey(Long id);
int insert(UmsRoleMenuRelation record);
int insertSelective(UmsRoleMenuRelation record);
List<UmsRoleMenuRelation> selectByExample(UmsRoleMenuRelationExample example);
UmsRoleMenuRelation selectByPrimaryKey(Long id);
int updateByExampleSelective(@Param("record") UmsRoleMenuRelation record, @Param("example") UmsRoleMenuRelationExample example);
int updateByExample(@Param("record") UmsRoleMenuRelation record, @Param("example") UmsRoleMenuRelationExample example);
int updateByPrimaryKeySelective(UmsRoleMenuRelation record);
int updateByPrimaryKey(UmsRoleMenuRelation record);
}

@ -1,30 +0,0 @@
package com.macro.mall.mapper;
import com.macro.mall.model.UmsRolePermissionRelation;
import com.macro.mall.model.UmsRolePermissionRelationExample;
import java.util.List;
import org.apache.ibatis.annotations.Param;
public interface UmsRolePermissionRelationMapper {
long countByExample(UmsRolePermissionRelationExample example);
int deleteByExample(UmsRolePermissionRelationExample example);
int deleteByPrimaryKey(Long id);
int insert(UmsRolePermissionRelation record);
int insertSelective(UmsRolePermissionRelation record);
List<UmsRolePermissionRelation> selectByExample(UmsRolePermissionRelationExample example);
UmsRolePermissionRelation selectByPrimaryKey(Long id);
int updateByExampleSelective(@Param("record") UmsRolePermissionRelation record, @Param("example") UmsRolePermissionRelationExample example);
int updateByExample(@Param("record") UmsRolePermissionRelation record, @Param("example") UmsRolePermissionRelationExample example);
int updateByPrimaryKeySelective(UmsRolePermissionRelation record);
int updateByPrimaryKey(UmsRolePermissionRelation record);
}

@ -1,30 +0,0 @@
package com.macro.mall.mapper;
import com.macro.mall.model.UmsRoleResourceRelation;
import com.macro.mall.model.UmsRoleResourceRelationExample;
import java.util.List;
import org.apache.ibatis.annotations.Param;
public interface UmsRoleResourceRelationMapper {
long countByExample(UmsRoleResourceRelationExample example);
int deleteByExample(UmsRoleResourceRelationExample example);
int deleteByPrimaryKey(Long id);
int insert(UmsRoleResourceRelation record);
int insertSelective(UmsRoleResourceRelation record);
List<UmsRoleResourceRelation> selectByExample(UmsRoleResourceRelationExample example);
UmsRoleResourceRelation selectByPrimaryKey(Long id);
int updateByExampleSelective(@Param("record") UmsRoleResourceRelation record, @Param("example") UmsRoleResourceRelationExample example);
int updateByExample(@Param("record") UmsRoleResourceRelation record, @Param("example") UmsRoleResourceRelationExample example);
int updateByPrimaryKeySelective(UmsRoleResourceRelation record);
int updateByPrimaryKey(UmsRoleResourceRelation record);
}

@ -1,108 +0,0 @@
package com.macro.mall.model;
import io.swagger.annotations.ApiModelProperty;
import java.io.Serializable;
import java.util.Date;
public class CmsHelp implements Serializable {
private Long id;
private Long categoryId;
private String icon;
private String title;
private Integer showStatus;
private Date createTime;
private Integer readCount;
private String content;
private static final long serialVersionUID = 1L;
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public Long getCategoryId() {
return categoryId;
}
public void setCategoryId(Long categoryId) {
this.categoryId = categoryId;
}
public String getIcon() {
return icon;
}
public void setIcon(String icon) {
this.icon = icon;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public Integer getShowStatus() {
return showStatus;
}
public void setShowStatus(Integer showStatus) {
this.showStatus = showStatus;
}
public Date getCreateTime() {
return createTime;
}
public void setCreateTime(Date createTime) {
this.createTime = createTime;
}
public Integer getReadCount() {
return readCount;
}
public void setReadCount(Integer readCount) {
this.readCount = readCount;
}
public String getContent() {
return content;
}
public void setContent(String content) {
this.content = content;
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append(getClass().getSimpleName());
sb.append(" [");
sb.append("Hash = ").append(hashCode());
sb.append(", id=").append(id);
sb.append(", categoryId=").append(categoryId);
sb.append(", icon=").append(icon);
sb.append(", title=").append(title);
sb.append(", showStatus=").append(showStatus);
sb.append(", createTime=").append(createTime);
sb.append(", readCount=").append(readCount);
sb.append(", content=").append(content);
sb.append(", serialVersionUID=").append(serialVersionUID);
sb.append("]");
return sb.toString();
}
}

@ -1,109 +0,0 @@
package com.macro.mall.model;
import io.swagger.annotations.ApiModelProperty;
import java.io.Serializable;
public class CmsHelpCategory implements Serializable {
private Long id;
private String name;
@ApiModelProperty(value = "分类图标")
private String icon;
@ApiModelProperty(value = "专题数量")
private Integer helpCount;
private Integer showStatus;
private Integer sort;
private static final long serialVersionUID = 1L;
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getIcon() {
return icon;
}
public void setIcon(String icon) {
this.icon = icon;
}
public Integer getHelpCount() {
return helpCount;
}
public void setHelpCount(Integer helpCount) {
this.helpCount = helpCount;
}
public Integer getShowStatus() {
return showStatus;
}
public void setShowStatus(Integer showStatus) {
this.showStatus = showStatus;
}
public Integer getSort() {
return sort;
}
public void setSort(Integer sort) {
this.sort = sort;
}
@Override
public String toString() {
// 创建一个StringBuilder对象用于高效地构建字符串
StringBuilder sb = new StringBuilder();
// 获取当前类的简单名称并追加到StringBuilder中
sb.append(getClass().getSimpleName());
sb.append(" [");
// 追加对象的哈希码
sb.append("Hash = ").append(hashCode());
// 追加id字段的值
sb.append(", id=").append(id);
// 追加name字段的值
sb.append(", name=").append(name);
// 追加icon字段的值
sb.append(", icon=").append(icon);
// 追加helpCount字段的值
sb.append(", helpCount=").append(helpCount);
// 追加showStatus字段的值
sb.append(", showStatus=").append(showStatus);
// 追加sort字段的值
sb.append(", sort=").append(sort);
// 追加serialVersionUID字段的值
sb.append(", serialVersionUID=").append(serialVersionUID);
// 结束字符串构建并返回结果
sb.append("]");
return sb.toString();
}
}

@ -1,724 +0,0 @@
package com.macro.mall.model;
import java.util.ArrayList;
import java.util.List;
public class CmsHelpCategoryExample {
// 定义排序子句
protected String orderByClause;
// 是否使用 DISTINCT 关键字
protected boolean distinct;
// 存储查询条件的列表
protected List<Criteria> oredCriteria;
/**
*
*/
public CmsHelpCategoryExample() {
oredCriteria = new ArrayList<>();
}
/**
*
* @param orderByClause
*/
public void setOrderByClause(String orderByClause) {
this.orderByClause = orderByClause;
}
/**
*
* @return
*/
public String getOrderByClause() {
return orderByClause;
}
/**
* 使 DISTINCT
* @param distinct true 使 DISTINCT false 使
*/
public void setDistinct(boolean distinct) {
this.distinct = distinct;
}
/**
* 使 DISTINCT
* @return 使 DISTINCT true false
*/
public boolean isDistinct() {
return distinct;
}
/**
*
* @return
*/
public List<Criteria> getOredCriteria() {
return oredCriteria;
}
/**
*
* @param criteria
*/
public void or(Criteria criteria) {
oredCriteria.add(criteria);
}
public Criteria or() {
// 创建一个新的Criteria对象
Criteria criteria = createCriteriaInternal();
// 将新的Criteria对象添加到oredCriteria列表中
oredCriteria.add(criteria);
// 返回新创建的Criteria对象
return criteria;
}
public Criteria createCriteria() {
// 创建一个新的Criteria对象
Criteria criteria = createCriteriaInternal();
// 如果oredCriteria列表为空则将新的Criteria对象添加到列表中
if (oredCriteria.size() == 0) {
oredCriteria.add(criteria);
}
// 返回新创建的Criteria对象
return criteria;
}
protected Criteria createCriteriaInternal() {
// 创建并返回一个新的Criteria对象
Criteria criteria = new Criteria();
return criteria;
}
public void clear() {
// 清空oredCriteria列表
oredCriteria.clear();
// 将orderByClause设置为null
orderByClause = null;
// 将distinct标志设置为false
distinct = false;
}
protected abstract static class GeneratedCriteria {
// 存储Criterion对象的列表
protected List<Criterion> criteria; // 存储查询条件的列表
protected GeneratedCriteria() {
// 调用父类的构造函数
super();
// 初始化criteria列表
criteria = new ArrayList<>();
}
public boolean isValid() {
// 检查criteria列表是否包含至少一个Criterion对象
return criteria.size() > 0;
}
public List<Criterion> getAllCriteria() {
// 返回所有Criterion对象的列表
return criteria;
}
public List<Criterion> getCriteria() {
// 返回所有Criterion对象的列表
return criteria;
}
protected void addCriterion(String condition) {
// 如果条件为空,抛出运行时异常
if (condition == null) {
throw new RuntimeException("Value for condition cannot be null");
}
// 将新的Criterion对象添加到criteria列表中
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");
}
// 将新的Criterion对象带值添加到criteria列表中
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");
}
// 将新的Criterion对象带两个值添加到criteria列表中
criteria.add(new Criterion(condition, value1, value2));
}
public Criteria andIdIsNull() {
// 添加条件“id is null”到criteria列表中
addCriterion("id is null");
return (Criteria) this;
}
public Criteria andIdIsNotNull() {
// 添加条件“id is not null”到criteria列表中
addCriterion("id is not null");
return (Criteria) this;
}
public Criteria andIdEqualTo(Long value) {
// 添加条件“id = value”到criteria列表中
addCriterion("id =", value, "id");
return (Criteria) this;
}
public Criteria andIdNotEqualTo(Long value) {
// 添加条件“id <> value”到criteria列表中
addCriterion("id <>", value, "id");
return (Criteria) this;
}
public Criteria andIdGreaterThan(Long value) {
// 添加条件“id > value”到criteria列表中
addCriterion("id >", value, "id");
return (Criteria) this;
}
public Criteria andIdGreaterThanOrEqualTo(Long value) {
// 添加条件“id >= value”到criteria列表中
addCriterion("id >=", value, "id");
return (Criteria) this;
}
public Criteria andIdLessThan(Long value) {
// 添加条件“id < value”到criteria列表中
addCriterion("id <", value, "id");
return (Criteria) this;
}
public Criteria andIdLessThanOrEqualTo(Long value) {
// 添加条件“id <= value”到criteria列表中
addCriterion("id <=", value, "id");
return (Criteria) this;
}
public Criteria andIdIn(List<Long> values) {
// 添加条件“id in (values)”到criteria列表中
addCriterion("id in", values, "id");
return (Criteria) this;
}
public Criteria andIdNotIn(List<Long> values) {
// 添加条件“id not in (values)”到criteria列表中
addCriterion("id not in", values, "id");
return (Criteria) this;
}
public Criteria andIdBetween(Long value1, Long value2) {
// 添加条件“id between value1 and value2”到criteria列表中
addCriterion("id between", value1, value2, "id");
return (Criteria) this;
}
public Criteria andIdNotBetween(Long value1, Long value2) {
// 添加条件“id not between value1 and value2”到criteria列表中
addCriterion("id not between", value1, value2, "id");
return (Criteria) this;
}
public Criteria andNameIsNull() {
// 添加条件“name is null”到criteria列表中
addCriterion("name is null");
return (Criteria) this;
}
public Criteria andNameIsNotNull() {
// 添加条件“name is not null”到criteria列表中
addCriterion("name is not null");
return (Criteria) this;
}
public Criteria andNameEqualTo(String value) {
// 添加条件“name = value”到criteria列表中
addCriterion("name =", value, "name");
return (Criteria) this;
}
public Criteria andNameNotEqualTo(String value) {
// 添加条件“name <> value”到criteria列表中
addCriterion("name <>", value, "name");
return (Criteria) this;
}
public Criteria andNameGreaterThan(String value) {
// 添加条件“name > value”到criteria列表中
addCriterion("name >", value, "name");
return (Criteria) this;
}
public Criteria andNameGreaterThanOrEqualTo(String value) {
// 添加条件“name >= value”到criteria列表中
addCriterion("name >=", value, "name");
return (Criteria) this;
}
public Criteria andNameLessThan(String value) {
// 添加条件“name < value”到criteria列表中
addCriterion("name <", value, "name");
return (Criteria) this;
}
public Criteria andNameLessThanOrEqualTo(String value) {
// 添加条件 "name <= value" 到criteria列表中
addCriterion("name <=", value, "name");
return (Criteria) this;
}
public Criteria andNameLike(String value) {
// 添加条件 "name like value" 到criteria列表中
addCriterion("name like", value, "name");
return (Criteria) this;
}
public Criteria andNameNotLike(String value) {
// 添加条件 "name not like value" 到criteria列表中
addCriterion("name not like", value, "name");
return (Criteria) this;
}
public Criteria andNameIn(List<String> values) {
// 添加条件 "name in (values)" 到criteria列表中
addCriterion("name in", values, "name");
return (Criteria) this;
}
public Criteria andNameNotIn(List<String> values) {
// 添加条件 "name not in (values)" 到criteria列表中
addCriterion("name not in", values, "name");
return (Criteria) this;
}
public Criteria andNameBetween(String value1, String value2) {
// 添加条件 "name between value1 and value2"
addCriterion("name between", value1, value2, "name");
return (Criteria) this;
}
public Criteria andNameNotBetween(String value1, String value2) {
// 添加条件 "name not between value1 and value2"
addCriterion("name not between", value1, value2, "name");
return (Criteria) this;
}
public Criteria andIconIsNull() {
// 添加条件 "icon is null"
addCriterion("icon is null");
return (Criteria) this;
}
public Criteria andIconIsNotNull() {
// 添加条件 "icon is not null"
addCriterion("icon is not null");
return (Criteria) this;
}
public Criteria andIconEqualTo(String value) {
// 添加条件 "icon = value"
addCriterion("icon =", value, "icon");
return (Criteria) this;
}
public Criteria andIconNotEqualTo(String value) {
// 添加条件 "icon <> value"
addCriterion("icon <>", value, "icon");
return (Criteria) this;
}
public Criteria andIconGreaterThan(String value) {
// 添加条件 "icon > value"
addCriterion("icon >", value, "icon");
return (Criteria) this;
}
public Criteria andIconGreaterThanOrEqualTo(String value) {
// 添加条件 "icon >= value"
addCriterion("icon >=", value, "icon");
return (Criteria) this;
}
public Criteria andIconLessThan(String value) {
// 添加条件 "icon < value"
addCriterion("icon <", value, "icon");
return (Criteria) this;
}
public Criteria andIconLessThanOrEqualTo(String value) {
// 添加条件 "icon <= value"
addCriterion("icon <=", value, "icon");
return (Criteria) this;
}
public Criteria andIconLike(String value) {
// 添加条件 "icon like value"
addCriterion("icon like", value, "icon");
return (Criteria) this;
}
public Criteria andIconNotLike(String value) {
// 添加条件 "icon not like value"
addCriterion("icon not like", value, "icon");
return (Criteria) this;
}
public Criteria andIconIn(List<String> values) {
// 添加条件 "icon in (values)"
addCriterion("icon in", values, "icon");
return (Criteria) this;
}
public Criteria andIconNotIn(List<String> values) {
// 添加条件 "icon not in (values)"
addCriterion("icon not in", values, "icon");
return (Criteria) this;
}
public Criteria andIconBetween(String value1, String value2) {
// 添加条件 "icon between value1 and value2"
addCriterion("icon between", value1, value2, "icon");
return (Criteria) this;
}
public Criteria andIconNotBetween(String value1, String value2) {
// 添加条件 "icon not between value1 and value2"
addCriterion("icon not between", value1, value2, "icon");
return (Criteria) this;
}
public Criteria andHelpCountIsNull() {
// 添加条件 "help_count is null"
addCriterion("help_count is null");
return (Criteria) this;
}
public Criteria andHelpCountIsNotNull() {
// 添加条件 "help_count is not null"
addCriterion("help_count is not null");
return (Criteria) this;
}
public Criteria andHelpCountEqualTo(Integer value) {
// 添加条件 "help_count = value"
addCriterion("help_count =", value, "helpCount");
return (Criteria) this;
}
public Criteria andHelpCountNotEqualTo(Integer value) {
// 添加条件 "help_count <> value"
addCriterion("help_count <>", value, "helpCount");
return (Criteria) this;
}
public Criteria andHelpCountGreaterThan(Integer value) {
// 添加条件 "help_count > value"
addCriterion("help_count >", value, "helpCount");
return (Criteria) this;
}
public Criteria andHelpCountGreaterThanOrEqualTo(Integer value) {
// 添加条件 "help_count >= value"
addCriterion("help_count >=", value, "helpCount");
return (Criteria) this;
}
public Criteria andHelpCountLessThan(Integer value) {
// 添加条件 "help_count < value"
addCriterion("help_count <", value, "helpCount");
return (Criteria) this;
}
public Criteria andHelpCountLessThanOrEqualTo(Integer value) {
// 添加条件 "help_count <= value"
addCriterion("help_count <=", value, "helpCount");
return (Criteria) this;
}
public Criteria andHelpCountIn(List<Integer> values) {
// 添加条件 "help_count in (values)"
addCriterion("help_count in", values, "helpCount");
return (Criteria) this;
}
public Criteria andHelpCountNotIn(List<Integer> values) {
// 添加条件 "help_count not in (values)"
addCriterion("help_count not in", values, "helpCount");
return (Criteria) this;
}
public Criteria andHelpCountBetween(Integer value1, Integer value2) {
// 添加条件 "help_count between value1 and value2"
addCriterion("help_count between", value1, value2, "helpCount");
return (Criteria) this;
}
public Criteria andHelpCountNotBetween(Integer value1, Integer value2) {
// 添加条件 "help_count not between value1 and value2"
addCriterion("help_count not between", value1, value2, "helpCount");
return (Criteria) this;
}
public Criteria andShowStatusIsNull() {
// 添加条件 "show_status is null"
addCriterion("show_status is null");
return (Criteria) this;
}
public Criteria andShowStatusIsNotNull() {
// 添加条件 "show_status is not null"
addCriterion("show_status is not null");
return (Criteria) this;
}
public Criteria andShowStatusEqualTo(Integer value) {
// 添加条件 "show_status = value"
addCriterion("show_status =", value, "showStatus");
return (Criteria) this;
}
public Criteria andShowStatusNotEqualTo(Integer value) {
// 添加条件 "show_status <> value"
addCriterion("show_status <>", value, "showStatus");
return (Criteria) this;
}
public Criteria andShowStatusGreaterThan(Integer value) {
// 添加条件 "show_status > value"
addCriterion("show_status >", value, "showStatus");
return (Criteria) this;
}
public Criteria andShowStatusGreaterThanOrEqualTo(Integer value) {
// 添加条件 "show_status >= value"
addCriterion("show_status >=", value, "showStatus");
return (Criteria) this;
}
public Criteria andShowStatusLessThan(Integer value) {
// 添加条件 "show_status < value"
addCriterion("show_status <", value, "showStatus");
return (Criteria) this;
}
public Criteria andShowStatusLessThanOrEqualTo(Integer value) {
// 添加条件 "show_status <= value"
addCriterion("show_status <=", value, "showStatus");
return (Criteria) this;
}
// 检查 show_status 是否在给定的值列表中
public Criteria andShowStatusIn(List<Integer> values) {
addCriterion("show_status in", values, "showStatus");
return (Criteria) this;
}
// 检查 show_status 是否不在给定的值列表中
public Criteria andShowStatusNotIn(List<Integer> values) {
addCriterion("show_status not in", values, "showStatus");
return (Criteria) this;
}
// 检查 show_status 是否在给定的两个值之间(包含边界)
public Criteria andShowStatusBetween(Integer value1, Integer value2) {
addCriterion("show_status between", value1, value2, "showStatus");
return (Criteria) this;
}
// 检查 show_status 是否不在给定的两个值之间(不包含边界)
public Criteria andShowStatusNotBetween(Integer value1, Integer value2) {
addCriterion("show_status not between", value1, value2, "showStatus");
return (Criteria) this;
}
// 检查 sort 字段是否为空
public Criteria andSortIsNull() {
addCriterion("sort is null");
return (Criteria) this;
}
// 检查 sort 字段是否不为空
public Criteria andSortIsNotNull() {
addCriterion("sort is not null");
return (Criteria) this;
}
// 检查 sort 是否等于给定的值
public Criteria andSortEqualTo(Integer value) {
addCriterion("sort =", value, "sort");
return (Criteria) this;
}
// 检查 sort 是否不等于给定的值
public Criteria andSortNotEqualTo(Integer value) {
addCriterion("sort <>", value, "sort");
return (Criteria) this;
}
// 检查 sort 是否大于给定的值
public Criteria andSortGreaterThan(Integer value) {
addCriterion("sort >", value, "sort");
return (Criteria) this;
}
// 检查 sort 是否大于或等于给定的值
public Criteria andSortGreaterThanOrEqualTo(Integer value) {
addCriterion("sort >=", value, "sort");
return (Criteria) this;
}
// 检查 sort 是否小于给定的值
public Criteria andSortLessThan(Integer value) {
addCriterion("sort <", value, "sort");
return (Criteria) this;
}
// 检查 sort 是否小于或等于给定的值
public Criteria andSortLessThanOrEqualTo(Integer value) {
addCriterion("sort <=", value, "sort");
return (Criteria) this;
}
// 检查 sort 是否在给定的值列表中
public Criteria andSortIn(List<Integer> values) {
addCriterion("sort in", values, "sort");
return (Criteria) this;
}
// 检查 sort 是否不在给定的值列表中
public Criteria andSortNotIn(List<Integer> values) {
addCriterion("sort not in", values, "sort");
return (Criteria) this;
}
// 检查 sort 是否在给定的两个值之间(包含边界)
public Criteria andSortBetween(Integer value1, Integer value2) {
addCriterion("sort between", value1, value2, "sort");
return (Criteria) this;
}
// 检查 sort 是否不在给定的两个值之间(不包含边界)
public Criteria andSortNotBetween(Integer value1, Integer value2) {
addCriterion("sort not between", value1, value2, "sort");
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;
}
}
// 构造函数用于创建一个Criterion对象只包含条件和值
protected Criterion(String condition, Object value) {
// 调用另一个构造函数并传递null作为第三个参数
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);
}
}
}

@ -1,738 +0,0 @@
package com.macro.mall.model;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
public class CmsHelpExample {
// 定义一个字符串变量用于存储排序子句
protected String orderByClause;
// 定义一个布尔变量用于指示是否使用 DISTINCT 关键字
protected boolean distinct;
// 定义一个列表用于存储查询条件Criteria
protected List<Criteria> oredCriteria;
// 构造函数,初始化 oredCriteria 列表
public CmsHelpExample() {
oredCriteria = new ArrayList<>();
}
// 设置排序子句的方法
public void setOrderByClause(String orderByClause) {
this.orderByClause = orderByClause;
}
// 获取排序子句的方法
public String getOrderByClause() {
return orderByClause;
}
// 设置是否使用 DISTINCT 关键字的方法
public void setDistinct(boolean distinct) {
this.distinct = distinct;
}
// 获取是否使用 DISTINCT 关键字的方法
public boolean isDistinct() {
return distinct;
}
// 获取查询条件列表的方法
public List<Criteria> getOredCriteria() {
return oredCriteria;
}
// 向查询条件列表中添加一个新的 Criteria 对象
public void or(Criteria criteria) {
oredCriteria.add(criteria);
}
// 创建一个新的 Criteria 对象并添加到查询条件列表中,然后返回该对象
public Criteria or() {
Criteria criteria = createCriteriaInternal();
oredCriteria.add(criteria);
return criteria;
}
// 创建一个 Criteria 对象,如果查询条件列表为空则将其添加到列表中,最后返回该对象
public Criteria createCriteria() {
Criteria criteria = createCriteriaInternal();
if (oredCriteria.size() == 0) {
oredCriteria.add(criteria);
}
return criteria;
}
// 内部方法,用于创建一个新的 Criteria 对象
protected Criteria createCriteriaInternal() {
Criteria criteria = new Criteria();
return criteria;
}
// 清除所有查询条件和排序子句,并将 distinct 设置为 false
public void clear() {
oredCriteria.clear();
orderByClause = null;
distinct = false;
}
protected abstract static class GeneratedCriteria {
// 定义一个保护的列表来存储所有的查询条件
protected List<Criterion> criteria;
// 构造函数初始化criteria列表
protected GeneratedCriteria() {
super();
criteria = new ArrayList<>();
}
// 检查是否有任何查询条件
public boolean isValid() {
return criteria.size() > 0;
}
// 获取所有查询条件的列表
public List<Criterion> getAllCriteria() {
return criteria;
}
// 获取查询条件的列表与getAllCriteria相同
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));
}
// 添加一个范围查询条件例如BETWEEN语句
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;
}
public Criteria andIdIsNotNull() {
addCriterion("id is not null");
return (Criteria) this;
}
public Criteria andIdEqualTo(Long value) {
addCriterion("id =", value, "id");
return (Criteria) this;
}
public Criteria andIdNotEqualTo(Long value) {
addCriterion("id <>", value, "id");
return (Criteria) this;
}
public Criteria andIdGreaterThan(Long value) {
addCriterion("id >", value, "id");
return (Criteria) this;
}
public Criteria andIdGreaterThanOrEqualTo(Long value) {
addCriterion("id >=", value, "id");
return (Criteria) this;
}
public Criteria andIdLessThan(Long value) {
addCriterion("id <", value, "id");
return (Criteria) this;
}
public Criteria andIdLessThanOrEqualTo(Long value) {
addCriterion("id <=", value, "id");
return (Criteria) this;
}
public Criteria andIdIn(List<Long> values) {
addCriterion("id in", values, "id");
return (Criteria) this;
}
public Criteria andIdNotIn(List<Long> values) {
addCriterion("id not in", values, "id");
return (Criteria) this;
}
public Criteria andIdBetween(Long value1, Long value2) {
addCriterion("id between", value1, value2, "id");
return (Criteria) this;
}
public Criteria andIdNotBetween(Long value1, Long value2) {
addCriterion("id not between", value1, value2, "id");
return (Criteria) this;
}
// 以下方法用于生成category_id的各种比较操作
public Criteria andCategoryIdIsNull() {
addCriterion("category_id is null");
return (Criteria) this;
}
public Criteria andCategoryIdIsNotNull() {
addCriterion("category_id is not null");
return (Criteria) this;
}
public Criteria andCategoryIdEqualTo(Long value) {
addCriterion("category_id =", value, "categoryId");
return (Criteria) this;
}
public Criteria andCategoryIdNotEqualTo(Long value) {
addCriterion("category_id <>", value, "categoryId");
return (Criteria) this;
}
public Criteria andCategoryIdGreaterThan(Long value) {
addCriterion("category_id >", value, "categoryId");
return (Criteria) this;
}
public Criteria andCategoryIdGreaterThanOrEqualTo(Long value) {
addCriterion("category_id >=", value, "categoryId");
return (Criteria) this;
}
public Criteria andCategoryIdLessThan(Long value) {
addCriterion("category_id <", value, "categoryId");
return (Criteria) this;
}
public Criteria andCategoryIdLessThanOrEqualTo(Long value) {
addCriterion("category_id <=", value, "categoryId");
return (Criteria) this;
}
public Criteria andCategoryIdIn(List<Long> values) {
addCriterion("category_id in", values, "categoryId");
return (Criteria) this;
}
public Criteria andCategoryIdNotIn(List<Long> values) {
addCriterion("category_id not in", values, "categoryId");
return (Criteria) this;
}
public Criteria andCategoryIdBetween(Long value1, Long value2) {
addCriterion("category_id between", value1, value2, "categoryId");
return (Criteria) this;
}
public Criteria andCategoryIdNotBetween(Long value1, Long value2) {
addCriterion("category_id not between", value1, value2, "categoryId");
return (Criteria) this;
}
// 以下方法用于生成icon字段的各种比较操作
public Criteria andIconIsNull() {
addCriterion("icon is null");
return (Criteria) this;
}
// 检查icon字段是否不为空
public Criteria andIconIsNotNull() {
addCriterion("icon is not null");
return (Criteria) this;
}
// 检查icon字段是否等于指定值
public Criteria andIconEqualTo(String value) {
addCriterion("icon =", value, "icon");
return (Criteria) this;
}
// 检查icon字段是否不等于指定值
public Criteria andIconNotEqualTo(String value) {
addCriterion("icon <>", value, "icon");
return (Criteria) this;
}
// 检查icon字段是否大于指定值
public Criteria andIconGreaterThan(String value) {
addCriterion("icon >", value, "icon");
return (Criteria) this;
}
// 检查icon字段是否大于或等于指定值
public Criteria andIconGreaterThanOrEqualTo(String value) {
addCriterion("icon >=", value, "icon");
return (Criteria) this;
}
// 检查icon字段是否小于指定值
public Criteria andIconLessThan(String value) {
addCriterion("icon <", value, "icon");
return (Criteria) this;
}
// 检查icon字段是否小于或等于指定值
public Criteria andIconLessThanOrEqualTo(String value) {
addCriterion("icon <=", value, "icon");
return (Criteria) this;
}
// 检查icon字段是否匹配指定模式使用LIKE
public Criteria andIconLike(String value) {
addCriterion("icon like", value, "icon");
return (Criteria) this;
}
// 检查icon字段是否不匹配指定模式使用NOT LIKE
public Criteria andIconNotLike(String value) {
addCriterion("icon not like", value, "icon");
return (Criteria) this;
}
// 检查icon字段是否在指定列表中
public Criteria andIconIn(List<String> values) {
addCriterion("icon in", values, "icon");
return (Criteria) this;
}
// 检查icon字段是否不在指定列表中
public Criteria andIconNotIn(List<String> values) {
addCriterion("icon not in", values, "icon");
return (Criteria) this;
}
// 检查icon字段是否在指定范围内使用BETWEEN
public Criteria andIconBetween(String value1, String value2) {
addCriterion("icon between", value1, value2, "icon");
return (Criteria) this;
}
// 检查icon字段是否不在指定范围内使用NOT BETWEEN
public Criteria andIconNotBetween(String value1, String value2) {
addCriterion("icon not between", value1, value2, "icon");
return (Criteria) this;
}
// 检查title字段是否为空
public Criteria andTitleIsNull() {
addCriterion("title is null");
return (Criteria) this;
}
// 检查title字段是否不为空
public Criteria andTitleIsNotNull() {
addCriterion("title is not null");
return (Criteria) this;
}
// 检查title字段是否等于指定值
public Criteria andTitleEqualTo(String value) {
addCriterion("title =", value, "title");
return (Criteria) this;
}
// 检查title字段是否不等于指定值
public Criteria andTitleNotEqualTo(String value) {
addCriterion("title <>", value, "title");
return (Criteria) this;
}
// 检查title字段是否大于指定值
public Criteria andTitleGreaterThan(String value) {
addCriterion("title >", value, "title");
return (Criteria) this;
}
// 检查title字段是否大于或等于指定值
public Criteria andTitleGreaterThanOrEqualTo(String value) {
addCriterion("title >=", value, "title");
return (Criteria) this;
}
// 检查title字段是否小于指定值
public Criteria andTitleLessThan(String value) {
addCriterion("title <", value, "title");
return (Criteria) this;
}
// 检查title字段是否小于或等于指定值
public Criteria andTitleLessThanOrEqualTo(String value) {
addCriterion("title <=", value, "title");
return (Criteria) this;
}
// 检查title字段是否匹配指定模式使用LIKE
public Criteria andTitleLike(String value) {
addCriterion("title like", value, "title");
return (Criteria) this;
}
// 检查title字段是否不匹配指定模式使用NOT LIKE
public Criteria andTitleNotLike(String value) {
addCriterion("title not like", value, "title");
return (Criteria) this;
}
// 检查title字段是否在指定列表中
public Criteria andTitleIn(List<String> values) {
addCriterion("title in", values, "title");
return (Criteria) this;
}
// 检查title字段是否不在指定列表中
public Criteria andTitleNotIn(List<String> values) {
addCriterion("title not in", values, "title");
return (Criteria) this;
}
// 检查title字段是否在指定范围内使用BETWEEN
public Criteria andTitleBetween(String value1, String value2) {
addCriterion("title between", value1, value2, "title");
return (Criteria) this;
}
// 检查title字段是否不在指定范围内使用NOT BETWEEN
public Criteria andTitleNotBetween(String value1, String value2) {
addCriterion("title not between", value1, value2, "title");
return (Criteria) this;
}
// 检查show_status字段是否为空
public Criteria andShowStatusIsNull() {
addCriterion("show_status is null");
return (Criteria) this;
}
// 检查show_status字段是否不为空
public Criteria andShowStatusIsNotNull() {
addCriterion("show_status is not null");
return (Criteria) this;
}
// 检查show_status字段是否等于指定值
public Criteria andShowStatusEqualTo(Integer value) {
addCriterion("show_status =", value, "showStatus");
return (Criteria) this;
}
// 检查 show_status 是否不等于指定值
public Criteria andShowStatusNotEqualTo(Integer value) {
addCriterion("show_status <>", value, "showStatus");
return (Criteria) this;
}
// 检查 show_status 是否大于指定值
public Criteria andShowStatusGreaterThan(Integer value) {
addCriterion("show_status >", value, "showStatus");
return (Criteria) this;
}
// 检查 show_status 是否大于或等于指定值
public Criteria andShowStatusGreaterThanOrEqualTo(Integer value) {
addCriterion("show_status >=", value, "showStatus");
return (Criteria) this;
}
// 检查 show_status 是否小于指定值
public Criteria andShowStatusLessThan(Integer value) {
addCriterion("show_status <", value, "showStatus");
return (Criteria) this;
}
// 检查 show_status 是否小于或等于指定值
public Criteria andShowStatusLessThanOrEqualTo(Integer value) {
addCriterion("show_status <=", value, "showStatus");
return (Criteria) this;
}
// 检查 show_status 是否在指定的列表中
public Criteria andShowStatusIn(List<Integer> values) {
addCriterion("show_status in", values, "showStatus");
return (Criteria) this;
}
// 检查 show_status 是否不在指定的列表中
public Criteria andShowStatusNotIn(List<Integer> values) {
addCriterion("show_status not in", values, "showStatus");
return (Criteria) this;
}
// 检查 show_status 是否在指定的范围内
public Criteria andShowStatusBetween(Integer value1, Integer value2) {
addCriterion("show_status between", value1, value2, "showStatus");
return (Criteria) this;
}
// 检查 show_status 是否不在指定的范围内
public Criteria andShowStatusNotBetween(Integer value1, Integer value2) {
addCriterion("show_status not between", value1, value2, "showStatus");
return (Criteria) this;
}
// 检查 create_time 是否为空
public Criteria andCreateTimeIsNull() {
addCriterion("create_time is null");
return (Criteria) this;
}
// 检查 create_time 是否不为空
public Criteria andCreateTimeIsNotNull() {
addCriterion("create_time is not null");
return (Criteria) this;
}
// 检查 create_time 是否等于指定值
public Criteria andCreateTimeEqualTo(Date value) {
addCriterion("create_time =", value, "createTime");
return (Criteria) this;
}
// 检查 create_time 是否不等于指定值
public Criteria andCreateTimeNotEqualTo(Date value) {
addCriterion("create_time <>", value, "createTime");
return (Criteria) this;
}
// 检查 create_time 是否大于指定值
public Criteria andCreateTimeGreaterThan(Date value) {
addCriterion("create_time >", value, "createTime");
return (Criteria) this;
}
// 检查 create_time 是否大于或等于指定值
public Criteria andCreateTimeGreaterThanOrEqualTo(Date value) {
addCriterion("create_time >=", value, "createTime");
return (Criteria) this;
}
// 检查 create_time 是否小于指定值
public Criteria andCreateTimeLessThan(Date value) {
addCriterion("create_time <", value, "createTime");
return (Criteria) this;
}
// 检查 create_time 是否小于或等于指定值
public Criteria andCreateTimeLessThanOrEqualTo(Date value) {
addCriterion("create_time <=", value, "createTime");
return (Criteria) this;
}
// 检查 create_time 是否在指定的列表中
public Criteria andCreateTimeIn(List<Date> values) {
addCriterion("create_time in", values, "createTime");
return (Criteria) this;
}
// 检查 create_time 是否不在指定的列表中
public Criteria andCreateTimeNotIn(List<Date> values) {
addCriterion("create_time not in", values, "createTime");
return (Criteria) this;
}
// 检查 create_time 是否在指定的范围内
public Criteria andCreateTimeBetween(Date value1, Date value2) {
addCriterion("create_time between", value1, value2, "createTime");
return (Criteria) this;
}
// 检查 create_time 是否不在指定的范围内
public Criteria andCreateTimeNotBetween(Date value1, Date value2) {
addCriterion("create_time not between", value1, value2, "createTime");
return (Criteria) this;
}
// 检查 read_count 是否为空
public Criteria andReadCountIsNull() {
addCriterion("read_count is null");
return (Criteria) this;
}
// 检查 read_count 是否不为空
public Criteria andReadCountIsNotNull() {
addCriterion("read_count is not null");
return (Criteria) this;
}
// 检查 read_count 是否等于指定值
public Criteria andReadCountEqualTo(Integer value) {
addCriterion("read_count =", value, "readCount");
return (Criteria) this;
}
// 检查 read_count 是否不等于指定值
public Criteria andReadCountNotEqualTo(Integer value) {
addCriterion("read_count <>", value, "readCount");
return (Criteria) this;
}
// 检查 read_count 是否大于指定值
public Criteria andReadCountGreaterThan(Integer value) {
addCriterion("read_count >", value, "readCount");
return (Criteria) this;
}
// 检查 read_count 是否大于或等于指定值
public Criteria andReadCountGreaterThanOrEqualTo(Integer value) {
addCriterion("read_count >=", value, "readCount");
return (Criteria) this;
}
// 检查 read_count 是否小于指定值
public Criteria andReadCountLessThan(Integer value) {
addCriterion("read_count <", value, "readCount");
return (Criteria) this;
}
// 检查 read_count 是否小于或等于指定值
public Criteria andReadCountLessThanOrEqualTo(Integer value) {
addCriterion("read_count <=", value, "readCount");
return (Criteria) this;
}
// 检查 read_count 是否在指定的列表中
public Criteria andReadCountIn(List<Integer> values) {
addCriterion("read_count in", values, "readCount");
return (Criteria) this;
}
// 检查 read_count 是否不在指定的列表中
public Criteria andReadCountNotIn(List<Integer> values) {
addCriterion("read_count not in", values, "readCount");
return (Criteria) this;
}
// 检查 read_count 是否在指定的范围内(包含边界)
public Criteria andReadCountBetween(Integer value1, Integer value2) {
addCriterion("read_count between", value1, value2, "readCount");
return (Criteria) this;
}
// 检查 read_count 是否不在指定的范围内(不包含边界)
public Criteria andReadCountNotBetween(Integer value1, Integer value2) {
addCriterion("read_count not between", value1, value2, "readCount");
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; // 第二个值用于between查询
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; // 如果值是列表则设置listValue为true
} else {
this.singleValue = true; // 否则设置为单个值
}
}
// 构造函数,包含条件表达式和值,不包含类型处理器
protected Criterion(String condition, Object value) {
this(condition, value, null); // 调用另一个构造函数并传递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); // 调用另一个构造函数并传递null作为类型处理器
}
}
}

@ -1,118 +0,0 @@
package com.macro.mall.model;
import io.swagger.annotations.ApiModelProperty;
import java.io.Serializable;
import java.util.Date;
/**
* CmsMemberReport
*
*/
public class CmsMemberReport implements Serializable {
private Long id; // 举报的唯一标识符
@ApiModelProperty(value = "举报类型0->商品评价1->话题内容2->用户评论")
private Integer reportType; // 举报的类型
@ApiModelProperty(value = "举报人")
private String reportMemberName; // 举报人的姓名
private Date createTime; // 举报的创建时间
private String reportObject; // 被举报的对象如商品ID或评论ID
@ApiModelProperty(value = "举报状态0->未处理1->已处理")
private Integer reportStatus; // 举报的处理状态
@ApiModelProperty(value = "处理结果0->无效1->有效2->恶意")
private Integer handleStatus; // 举报的处理结果
private String note; // 备注信息
private static final long serialVersionUID = 1L; // 序列化版本号
// Getter and Setter methods for each field
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public Integer getReportType() {
return reportType;
}
public void setReportType(Integer reportType) {
this.reportType = reportType;
}
public String getReportMemberName() {
return reportMemberName;
}
public void setReportMemberName(String reportMemberName) {
this.reportMemberName = reportMemberName;
}
public Date getCreateTime() {
return createTime;
}
public void setCreateTime(Date createTime) {
this.createTime = createTime;
}
public String getReportObject() {
return reportObject;
}
public void setReportObject(String reportObject) {
this.reportObject = reportObject;
}
public Integer getReportStatus() {
return reportStatus;
}
public void setReportStatus(Integer reportStatus) {
this.reportStatus = reportStatus;
}
public Integer getHandleStatus() {
return handleStatus;
}
public void setHandleStatus(Integer handleStatus) {
this.handleStatus = handleStatus;
}
public String getNote() {
return note;
}
public void setNote(String note) {
this.note = note;
}
// toString method to provide a string representation of the object
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append(getClass().getSimpleName());
sb.append(" [");
sb.append("Hash = ").append(hashCode());
sb.append(", id=").append(id);
sb.append(", reportType=").append(reportType);
sb.append(", reportMemberName=").append(reportMemberName);
sb.append(", createTime=").append(createTime);
sb.append(", reportObject=").append(reportObject);
sb.append(", reportStatus=").append(reportStatus);
sb.append(", handleStatus=").append(handleStatus);
sb.append(", note=").append(note);
sb.append(", serialVersionUID=").append(serialVersionUID);
sb.append("]");
return sb.toString();
}
}

@ -1,847 +0,0 @@
package com.macro.mall.model;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
public class CmsMemberReportExample {
// 定义一个用于排序的子句
protected String orderByClause;
// 定义一个布尔值,用于指示查询结果是否去重
protected boolean distinct;
// 定义一个列表用于存储查询条件Criteria
protected List<Criteria> oredCriteria;
// 构造函数初始化oredCriteria为一个新的ArrayList
public CmsMemberReportExample() {
oredCriteria = new ArrayList<>();
}
// 设置排序子句的方法
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;
}
// 添加一个查询条件到oredCriteria列表中的方法
public void or(Criteria criteria) {
oredCriteria.add(criteria);
}
// 创建一个新的Criteria对象并添加到oredCriteria列表中的方法
public Criteria or() {
Criteria criteria = createCriteriaInternal();
oredCriteria.add(criteria);
return criteria;
}
// 创建一个Criteria对象如果oredCriteria列表为空则将其添加到列表中的方法
public Criteria createCriteria() {
Criteria criteria = createCriteriaInternal();
if (oredCriteria.size() == 0) {
oredCriteria.add(criteria);
}
return criteria;
}
// 内部方法用于创建一个新的Criteria对象
protected Criteria createCriteriaInternal() {
Criteria criteria = new Criteria();
return criteria;
}
// 清除所有查询条件和排序子句并将distinct设置为false的方法
public void clear() {
oredCriteria.clear();
orderByClause = null;
distinct = false;
}
protected abstract static class GeneratedCriteria {
// 定义一个用于存储查询条件的列表
protected List<Criterion> criteria;
// 构造函数初始化criteria为一个新的ArrayList
protected GeneratedCriteria() {
super();
criteria = new ArrayList<>();
}
// 判断是否有查询条件的方法
public boolean isValid() {
return criteria.size() > 0;
}
// 获取所有查询条件的方法
public List<Criterion> getAllCriteria() {
return criteria;
}
// 获取查询条件列表的方法与getAllCriteria方法相同
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(Long value) {
addCriterion("id =", value, "id");
return (Criteria) this;
}
// 添加id不等于指定值的查询条件的方法
public Criteria andIdNotEqualTo(Long value) {
addCriterion("id <>", value, "id");
return (Criteria) this;
}
// 添加id大于指定值的查询条件的方法
public Criteria andIdGreaterThan(Long value) {
addCriterion("id >", value, "id");
return (Criteria) this;
}
// 添加id大于等于指定值的查询条件的方法
public Criteria andIdGreaterThanOrEqualTo(Long value) {
addCriterion("id >=", value, "id");
return (Criteria) this;
}
// 添加id小于指定值的查询条件的方法
public Criteria andIdLessThan(Long value) {
addCriterion("id <", value, "id");
return (Criteria) this;
}
// 添加id小于等于指定值的查询条件的方法
public Criteria andIdLessThanOrEqualTo(Long value) {
addCriterion("id <=", value, "id");
return (Criteria) this;
}
// 添加id在指定值列表中的查询条件的方法
public Criteria andIdIn(List<Long> values) {
addCriterion("id in", values, "id");
return (Criteria) this;
}
// 添加id不在指定值列表中的查询条件的方法
public Criteria andIdNotIn(List<Long> values) {
addCriterion("id not in", values, "id");
return (Criteria) this;
}
// 添加id在指定范围内的查询条件的方法
public Criteria andIdBetween(Long value1, Long value2) {
addCriterion("id between", value1, value2, "id");
return (Criteria) this;
}
// 添加id不在指定范围内的查询条件的方法
public Criteria andIdNotBetween(Long value1, Long value2) {
addCriterion("id not between", value1, value2, "id");
return (Criteria) this;
}
// 添加report_type为空的查询条件的方法
public Criteria andReportTypeIsNull() {
addCriterion("report_type is null");
return (Criteria) this;
}
// 添加report_type不为空的查询条件的方法
public Criteria andReportTypeIsNotNull() {
addCriterion("report_type is not null");
return (Criteria) this;
}
// 添加report_type等于指定值的查询条件的方法
public Criteria andReportTypeEqualTo(Integer value) {
addCriterion("report_type =", value, "reportType");
return (Criteria) this;
}
// 添加report_type不等于指定值的查询条件的方法
public Criteria andReportTypeNotEqualTo(Integer value) {
addCriterion("report_type <>", value, "reportType");
return (Criteria) this;
}
// 添加report_type大于指定值的查询条件的方法
public Criteria andReportTypeGreaterThan(Integer value) {
addCriterion("report_type >", value, "reportType");
return (Criteria) this;
}
// 添加report_type大于等于指定值的查询条件的方法
public Criteria andReportTypeGreaterThanOrEqualTo(Integer value) {
addCriterion("report_type >=", value, "reportType");
return (Criteria) this;
}
// 添加report_type小于指定值的查询条件的方法
public Criteria andReportTypeLessThan(Integer value) {
addCriterion("report_type <", value, "reportType");
return (Criteria) this;
}
// 添加 report_type <= value 的条件
public Criteria andReportTypeLessThanOrEqualTo(Integer value) {
addCriterion("report_type <=", value, "reportType");
return (Criteria) this;
}
// 添加 report_type in (values) 的条件
public Criteria andReportTypeIn(List<Integer> values) {
addCriterion("report_type in", values, "reportType");
return (Criteria) this;
}
// 添加 report_type not in (values) 的条件
public Criteria andReportTypeNotIn(List<Integer> values) {
addCriterion("report_type not in", values, "reportType");
return (Criteria) this;
}
// 添加 report_type between value1 and value2 的条件
public Criteria andReportTypeBetween(Integer value1, Integer value2) {
addCriterion("report_type between", value1, value2, "reportType");
return (Criteria) this;
}
// 添加 report_type not between value1 and value2 的条件
public Criteria andReportTypeNotBetween(Integer value1, Integer value2) {
addCriterion("report_type not between", value1, value2, "reportType");
return (Criteria) this;
}
// 添加 report_member_name is null 的条件
public Criteria andReportMemberNameIsNull() {
addCriterion("report_member_name is null");
return (Criteria) this;
}
// 添加 report_member_name is not null 的条件
public Criteria andReportMemberNameIsNotNull() {
addCriterion("report_member_name is not null");
return (Criteria) this;
}
// 添加 report_member_name = value 的条件
public Criteria andReportMemberNameEqualTo(String value) {
addCriterion("report_member_name =", value, "reportMemberName");
return (Criteria) this;
}
// 添加 report_member_name <> value 的条件
public Criteria andReportMemberNameNotEqualTo(String value) {
addCriterion("report_member_name <>", value, "reportMemberName");
return (Criteria) this;
}
// 添加 report_member_name > value 的条件
public Criteria andReportMemberNameGreaterThan(String value) {
addCriterion("report_member_name >", value, "reportMemberName");
return (Criteria) this;
}
// 添加 report_member_name >= value 的条件
public Criteria andReportMemberNameGreaterThanOrEqualTo(String value) {
addCriterion("report_member_name >=", value, "reportMemberName");
return (Criteria) this;
}
// 添加 report_member_name < value 的条件
public Criteria andReportMemberNameLessThan(String value) {
addCriterion("report_member_name <", value, "reportMemberName");
return (Criteria) this;
}
// 添加 report_member_name <= value 的条件
public Criteria andReportMemberNameLessThanOrEqualTo(String value) {
addCriterion("report_member_name <=", value, "reportMemberName");
return (Criteria) this;
}
// 添加 report_member_name like value 的条件
public Criteria andReportMemberNameLike(String value) {
addCriterion("report_member_name like", value, "reportMemberName");
return (Criteria) this;
}
// 添加 report_member_name not like value 的条件
public Criteria andReportMemberNameNotLike(String value) {
addCriterion("report_member_name not like", value, "reportMemberName");
return (Criteria) this;
}
// 添加 report_member_name in (values) 的条件
public Criteria andReportMemberNameIn(List<String> values) {
addCriterion("report_member_name in", values, "reportMemberName");
return (Criteria) this;
}
// 添加 report_member_name not in (values) 的条件
public Criteria andReportMemberNameNotIn(List<String> values) {
addCriterion("report_member_name not in", values, "reportMemberName");
return (Criteria) this;
}
// 添加 report_member_name between value1 and value2 的条件
public Criteria andReportMemberNameBetween(String value1, String value2) {
addCriterion("report_member_name between", value1, value2, "reportMemberName");
return (Criteria) this;
}
// 添加 report_member_name not between value1 and value2 的条件
public Criteria andReportMemberNameNotBetween(String value1, String value2) {
addCriterion("report_member_name not between", value1, value2, "reportMemberName");
return (Criteria) this;
}
// 添加 create_time is null 的条件
public Criteria andCreateTimeIsNull() {
addCriterion("create_time is null");
return (Criteria) this;
}
// 添加 create_time is not null 的条件
public Criteria andCreateTimeIsNotNull() {
addCriterion("create_time is not null");
return (Criteria) this;
}
// 添加 create_time = value 的条件
public Criteria andCreateTimeEqualTo(Date value) {
addCriterion("create_time =", value, "createTime");
return (Criteria) this;
}
// 添加 create_time <> value 的条件
public Criteria andCreateTimeNotEqualTo(Date value) {
addCriterion("create_time <>", value, "createTime");
return (Criteria) this;
}
// 添加 create_time > value 的条件
public Criteria andCreateTimeGreaterThan(Date value) {
addCriterion("create_time >", value, "createTime");
return (Criteria) this;
}
// 添加 create_time >= value 的条件
public Criteria andCreateTimeGreaterThanOrEqualTo(Date value) {
addCriterion("create_time >=", value, "createTime");
return (Criteria) this;
}
// 添加 create_time < value 的条件
public Criteria andCreateTimeLessThan(Date value) {
addCriterion("create_time <", value, "createTime");
return (Criteria) this;
}
// 添加 create_time <= value 的条件
public Criteria andCreateTimeLessThanOrEqualTo(Date value) {
addCriterion("create_time <=", value, "createTime");
return (Criteria) this;
}
// 添加 create_time in (values) 的条件
public Criteria andCreateTimeIn(List<Date> values) {
addCriterion("create_time in", values, "createTime");
return (Criteria) this;
}
// 添加 create_time not in (values) 的条件
public Criteria andCreateTimeNotIn(List<Date> values) {
addCriterion("create_time not in", values, "createTime");
return (Criteria) this;
}
// 添加创建时间在指定范围内的条件
public Criteria andCreateTimeBetween(Date value1, Date value2) {
addCriterion("create_time between", value1, value2, "createTime");
return (Criteria) this;
}
// 添加创建时间不在指定范围内的条件
public Criteria andCreateTimeNotBetween(Date value1, Date value2) {
addCriterion("create_time not between", value1, value2, "createTime");
return (Criteria) this;
}
// 添加报告对象为空的条件
public Criteria andReportObjectIsNull() {
addCriterion("report_object is null");
return (Criteria) this;
}
// 添加报告对象不为空的条件
public Criteria andReportObjectIsNotNull() {
addCriterion("report_object is not null");
return (Criteria) this;
}
// 添加报告对象等于指定值的条件
public Criteria andReportObjectEqualTo(String value) {
addCriterion("report_object =", value, "reportObject");
return (Criteria) this;
}
// 添加报告对象不等于指定值的条件
public Criteria andReportObjectNotEqualTo(String value) {
addCriterion("report_object <>", value, "reportObject");
return (Criteria) this;
}
// 添加报告对象大于指定值的条件
public Criteria andReportObjectGreaterThan(String value) {
addCriterion("report_object >", value, "reportObject");
return (Criteria) this;
}
// 添加报告对象大于或等于指定值的条件
public Criteria andReportObjectGreaterThanOrEqualTo(String value) {
addCriterion("report_object >=", value, "reportObject");
return (Criteria) this;
}
// 添加报告对象小于指定值的条件
public Criteria andReportObjectLessThan(String value) {
addCriterion("report_object <", value, "reportObject");
return (Criteria) this;
}
// 添加报告对象小于或等于指定值的条件
public Criteria andReportObjectLessThanOrEqualTo(String value) {
addCriterion("report_object <=", value, "reportObject");
return (Criteria) this;
}
// 添加报告对象匹配指定模式的条件
public Criteria andReportObjectLike(String value) {
addCriterion("report_object like", value, "reportObject");
return (Criteria) this;
}
// 添加报告对象不匹配指定模式的条件
public Criteria andReportObjectNotLike(String value) {
addCriterion("report_object not like", value, "reportObject");
return (Criteria) this;
}
// 添加报告对象在指定列表中的条件
public Criteria andReportObjectIn(List<String> values) {
addCriterion("report_object in", values, "reportObject");
return (Criteria) this;
}
// 添加报告对象不在指定列表中的条件
public Criteria andReportObjectNotIn(List<String> values) {
addCriterion("report_object not in", values, "reportObject");
return (Criteria) this;
}
// 添加报告对象在指定范围内的条件
public Criteria andReportObjectBetween(String value1, String value2) {
addCriterion("report_object between", value1, value2, "reportObject");
return (Criteria) this;
}
// 添加报告对象不在指定范围内的条件
public Criteria andReportObjectNotBetween(String value1, String value2) {
addCriterion("report_object not between", value1, value2, "reportObject");
return (Criteria) this;
}
// 添加报告状态为空的条件
public Criteria andReportStatusIsNull() {
addCriterion("report_status is null");
return (Criteria) this;
}
// 添加报告状态不为空的条件
public Criteria andReportStatusIsNotNull() {
addCriterion("report_status is not null");
return (Criteria) this;
}
// 添加报告状态等于指定值的条件
public Criteria andReportStatusEqualTo(Integer value) {
addCriterion("report_status =", value, "reportStatus");
return (Criteria) this;
}
// 添加报告状态不等于指定值的条件
public Criteria andReportStatusNotEqualTo(Integer value) {
addCriterion("report_status <>", value, "reportStatus");
return (Criteria) this;
}
// 添加报告状态大于指定值的条件
public Criteria andReportStatusGreaterThan(Integer value) {
addCriterion("report_status >", value, "reportStatus");
return (Criteria) this;
}
// 添加报告状态大于或等于指定值的条件
public Criteria andReportStatusGreaterThanOrEqualTo(Integer value) {
addCriterion("report_status >=", value, "reportStatus");
return (Criteria) this;
}
// 添加报告状态小于指定值的条件
public Criteria andReportStatusLessThan(Integer value) {
addCriterion("report_status <", value, "reportStatus");
return (Criteria) this;
}
// 添加报告状态小于或等于指定值的条件
public Criteria andReportStatusLessThanOrEqualTo(Integer value) {
addCriterion("report_status <=", value, "reportStatus");
return (Criteria) this;
}
// 添加报告状态在指定列表中的条件
public Criteria andReportStatusIn(List<Integer> values) {
addCriterion("report_status in", values, "reportStatus");
return (Criteria) this;
}
// 添加报告状态不在指定列表中的条件
public Criteria andReportStatusNotIn(List<Integer> values) {
addCriterion("report_status not in", values, "reportStatus");
return (Criteria) this;
}
// 添加报告状态在指定范围内的条件
public Criteria andReportStatusBetween(Integer value1, Integer value2) {
addCriterion("report_status between", value1, value2, "reportStatus");
return (Criteria) this;
}
// 添加报告状态不在指定范围内的条件
public Criteria andReportStatusNotBetween(Integer value1, Integer value2) {
addCriterion("report_status not between", value1, value2, "reportStatus");
return (Criteria) this;
}
// 添加处理状态为空的条件
public Criteria andHandleStatusIsNull() {
addCriterion("handle_status is null");
return (Criteria) this;
}
// 添加处理状态不为空的条件
public Criteria andHandleStatusIsNotNull() {
addCriterion("handle_status is not null");
return (Criteria) this;
}
// 添加处理状态等于指定值的条件
public Criteria andHandleStatusEqualTo(Integer value) {
addCriterion("handle_status =", value, "handleStatus");
return (Criteria) this;
}
// 添加处理状态不等于指定值的条件
public Criteria andHandleStatusNotEqualTo(Integer value) {
addCriterion("handle_status <>", value, "handleStatus");
return (Criteria) this;
}
// 添加条件handle_status > value
public Criteria andHandleStatusGreaterThan(Integer value) {
addCriterion("handle_status >", value, "handleStatus");
return (Criteria) this;
}
// 添加条件handle_status >= value
public Criteria andHandleStatusGreaterThanOrEqualTo(Integer value) {
addCriterion("handle_status >=", value, "handleStatus");
return (Criteria) this;
}
// 添加条件handle_status < value
public Criteria andHandleStatusLessThan(Integer value) {
addCriterion("handle_status <", value, "handleStatus");
return (Criteria) this;
}
// 添加条件handle_status <= value
public Criteria andHandleStatusLessThanOrEqualTo(Integer value) {
addCriterion("handle_status <=", value, "handleStatus");
return (Criteria) this;
}
// 添加条件handle_status in values
public Criteria andHandleStatusIn(List<Integer> values) {
addCriterion("handle_status in", values, "handleStatus");
return (Criteria) this;
}
// 添加条件handle_status not in values
public Criteria andHandleStatusNotIn(List<Integer> values) {
addCriterion("handle_status not in", values, "handleStatus");
return (Criteria) this;
}
// 添加条件handle_status between value1 and value2
public Criteria andHandleStatusBetween(Integer value1, Integer value2) {
addCriterion("handle_status between", value1, value2, "handleStatus");
return (Criteria) this;
}
// 添加条件handle_status not between value1 and value2
public Criteria andHandleStatusNotBetween(Integer value1, Integer value2) {
addCriterion("handle_status not between", value1, value2, "handleStatus");
return (Criteria) this;
}
// 添加条件note is null
public Criteria andNoteIsNull() {
addCriterion("note is null");
return (Criteria) this;
}
// 添加条件note is not null
public Criteria andNoteIsNotNull() {
addCriterion("note is not null");
return (Criteria) this;
}
// 添加条件note = value
public Criteria andNoteEqualTo(String value) {
addCriterion("note =", value, "note");
return (Criteria) this;
}
// 添加条件note <> value
public Criteria andNoteNotEqualTo(String value) {
addCriterion("note <>", value, "note");
return (Criteria) this;
}
// 添加条件note > value
public Criteria andNoteGreaterThan(String value) {
addCriterion("note >", value, "note");
return (Criteria) this;
}
// 添加条件note >= value
public Criteria andNoteGreaterThanOrEqualTo(String value) {
addCriterion("note >=", value, "note");
return (Criteria) this;
}
// 添加条件note < value
public Criteria andNoteLessThan(String value) {
addCriterion("note <", value, "note");
return (Criteria) this;
}
// 添加条件note <= value
public Criteria andNoteLessThanOrEqualTo(String value) {
addCriterion("note <=", value, "note");
return (Criteria) this;
}
// 添加条件note like value
public Criteria andNoteLike(String value) {
addCriterion("note like", value, "note");
return (Criteria) this;
}
// 添加条件note not like value
public Criteria andNoteNotLike(String value) {
addCriterion("note not like", value, "note");
return (Criteria) this;
}
// 添加条件note in values
public Criteria andNoteIn(List<String> values) {
addCriterion("note in", values, "note");
return (Criteria) this;
}
// 添加条件note not in values
public Criteria andNoteNotIn(List<String> values) {
addCriterion("note not in", values, "note");
return (Criteria) this;
}
// 添加条件note between value1 and value2
public Criteria andNoteBetween(String value1, String value2) {
addCriterion("note between", value1, value2, "note");
return (Criteria) this;
}
// 添加条件note not between value1 and value2
public Criteria andNoteNotBetween(String value1, String value2) {
addCriterion("note not between", value1, value2, "note");
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; // 第二个值用于between查询
private boolean noValue; // 是否没有值
private boolean singleValue; // 是否是单一值
private boolean betweenValue; // 是否是between查询
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;
}
// 判断是否是between查询
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; // 如果值是列表则设置listValue为true
} else {
this.singleValue = true; // 否则设置为单一值
}
}
// 构造函数,包含条件表达式和值,不包含类型处理器
protected Criterion(String condition, Object value) {
this(condition, value, null); // 调用另一个构造函数并传递null作为类型处理器
}
// 构造函数包含条件表达式、两个值和可选的类型处理器用于between查询
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; // 表示这是一个between查询
}
// 构造函数包含条件表达式、两个值不包含类型处理器用于between查询
protected Criterion(String condition, Object value, Object secondValue) {
this(condition, value, secondValue, null); // 调用另一个构造函数并传递null作为类型处理器
}
}
}

@ -1,91 +0,0 @@
package com.macro.mall.model;
import io.swagger.annotations.ApiModelProperty;
import java.io.Serializable;
/**
* CmsPrefrenceArea CMS
*/
public class CmsPrefrenceArea implements Serializable {
private Long id; // 主键ID
private String name; // 名称
private String subTitle; // 副标题
private Integer sort; // 排序
private Integer showStatus; // 显示状态
@ApiModelProperty(value = "展示图片")
private byte[] pic; // 展示图片,以字节数组形式存储
private static final long serialVersionUID = 1L; // 序列化版本号
// Getter和Setter方法
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getSubTitle() {
return subTitle;
}
public void setSubTitle(String subTitle) {
this.subTitle = subTitle;
}
public Integer getSort() {
return sort;
}
public void setSort(Integer sort) {
this.sort = sort;
}
public Integer getShowStatus() {
return showStatus;
}
public void setShowStatus(Integer showStatus) {
this.showStatus = showStatus;
}
public byte[] getPic() {
return pic;
}
public void setPic(byte[] pic) {
this.pic = pic;
}
// toString方法用于生成对象的字符串表示形式
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append(getClass().getSimpleName());
sb.append(" [");
sb.append("Hash = ").append(hashCode());
sb.append(", id=").append(id);
sb.append(", name=").append(name);
sb.append(", subTitle=").append(subTitle);
sb.append(", sort=").append(sort);
sb.append(", showStatus=").append(showStatus);
sb.append(", pic=").append(pic);
sb.append(", serialVersionUID=").append(serialVersionUID);
sb.append("]");
return sb.toString();
}
}

@ -1,595 +0,0 @@
package com.macro.mall.model;
import java.util.ArrayList;
import java.util.List;
public class CmsPrefrenceAreaExample {
// 定义一个用于排序的子句
protected String orderByClause;
// 定义一个布尔值,用于指示查询是否使用 DISTINCT 关键字
protected boolean distinct;
// 定义一个 Criteria 对象的列表,用于存储查询条件
protected List<Criteria> oredCriteria;
// 构造函数,初始化 oredCriteria 列表
public CmsPrefrenceAreaExample() {
oredCriteria = new ArrayList<>();
}
// 设置排序子句的方法
public void setOrderByClause(String orderByClause) {
this.orderByClause = orderByClause;
}
// 获取排序子句的方法
public String getOrderByClause() {
return orderByClause;
}
// 设置是否使用 DISTINCT 关键字的方法
public void setDistinct(boolean distinct) {
this.distinct = distinct;
}
// 获取是否使用 DISTINCT 关键字的方法
public boolean isDistinct() {
return distinct;
}
// 获取 Criteria 对象列表的方法
public List<Criteria> getOredCriteria() {
return oredCriteria;
}
// 将一个 Criteria 对象添加到 oredCriteria 列表中的方法
public void or(Criteria criteria) {
oredCriteria.add(criteria);
}
// 创建一个新的 Criteria 对象并添加到 oredCriteria 列表中的方法
public Criteria or() {
Criteria criteria = createCriteriaInternal();
oredCriteria.add(criteria);
return criteria;
}
// 创建一个新的 Criteria 对象,如果 oredCriteria 列表为空则将其添加到列表中的方法
public Criteria createCriteria() {
Criteria criteria = createCriteriaInternal();
if (oredCriteria.size() == 0) {
oredCriteria.add(criteria);
}
return criteria;
}
// 内部方法,用于创建一个新的 Criteria 对象
protected Criteria createCriteriaInternal() {
Criteria criteria = new Criteria();
return criteria;
}
// 清除所有查询条件和排序子句的方法
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<>();
}
// 判断是否有有效的查询条件
public boolean isValid() {
return criteria.size() > 0;
}
// 获取所有的查询条件
public List<Criterion> getAllCriteria() {
return criteria;
}
// 获取所有的查询条件与getAllCriteria方法功能相同
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));
}
// 添加一个带两个值的查询条件通常用于BETWEEN查询
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和name的各种比较操作
public Criteria andIdIsNull() {
addCriterion("id is null");
return (Criteria) this;
}
public Criteria andIdIsNotNull() {
addCriterion("id is not null");
return (Criteria) this;
}
public Criteria andIdEqualTo(Long value) {
addCriterion("id =", value, "id");
return (Criteria) this;
}
public Criteria andIdNotEqualTo(Long value) {
addCriterion("id <>", value, "id");
return (Criteria) this;
}
public Criteria andIdGreaterThan(Long value) {
addCriterion("id >", value, "id");
return (Criteria) this;
}
public Criteria andIdGreaterThanOrEqualTo(Long value) {
addCriterion("id >=", value, "id");
return (Criteria) this;
}
public Criteria andIdLessThan(Long value) {
addCriterion("id <", value, "id");
return (Criteria) this;
}
public Criteria andIdLessThanOrEqualTo(Long value) {
addCriterion("id <=", value, "id");
return (Criteria) this;
}
public Criteria andIdIn(List<Long> values) {
addCriterion("id in", values, "id");
return (Criteria) this;
}
public Criteria andIdNotIn(List<Long> values) {
addCriterion("id not in", values, "id");
return (Criteria) this;
}
public Criteria andIdBetween(Long value1, Long value2) {
addCriterion("id between", value1, value2, "id");
return (Criteria) this;
}
public Criteria andIdNotBetween(Long value1, Long value2) {
addCriterion("id not between", value1, value2, "id");
return (Criteria) this;
}
public Criteria andNameIsNull() {
addCriterion("name is null");
return (Criteria) this;
}
public Criteria andNameIsNotNull() {
addCriterion("name is not null");
return (Criteria) this;
}
public Criteria andNameEqualTo(String value) {
addCriterion("name =", value, "name");
return (Criteria) this;
}
public Criteria andNameNotEqualTo(String value) {
addCriterion("name <>", value, "name");
return (Criteria) this;
}
public Criteria andNameGreaterThan(String value) {
addCriterion("name >", value, "name");
return (Criteria) this;
}
public Criteria andNameGreaterThanOrEqualTo(String value) {
addCriterion("name >=", value, "name");
return (Criteria) this;
}
public Criteria andNameLessThan(String value) {
addCriterion("name <", value, "name");
return (Criteria) this;
}
public Criteria andNameLessThanOrEqualTo(String value) {
addCriterion("name <=", value, "name");
return (Criteria) this;
}
public Criteria andNameLike(String value) {
addCriterion("name like", value, "name");
return (Criteria) this;
}
public Criteria andNameNotLike(String value) {
addCriterion("name not like", value, "name");
return (Criteria) this;
}
public Criteria andNameIn(List<String> values) {
addCriterion("name in", values, "name");
return (Criteria) this;
}
public Criteria andNameNotIn(List<String> values) {
addCriterion("name not in", values, "name");
return (Criteria) this;
}
// 检查name字段是否在给定的两个值之间
public Criteria andNameBetween(String value1, String value2) {
addCriterion("name between", value1, value2, "name");
return (Criteria) this;
}
// 检查name字段是否不在给定的两个值之间
public Criteria andNameNotBetween(String value1, String value2) {
addCriterion("name not between", value1, value2, "name");
return (Criteria) this;
}
// 检查sub_title字段是否为空
public Criteria andSubTitleIsNull() {
addCriterion("sub_title is null");
return (Criteria) this;
}
// 检查sub_title字段是否不为空
public Criteria andSubTitleIsNotNull() {
addCriterion("sub_title is not null");
return (Criteria) this;
}
// 检查sub_title字段是否等于给定的值
public Criteria andSubTitleEqualTo(String value) {
addCriterion("sub_title =", value, "subTitle");
return (Criteria) this;
}
// 检查sub_title字段是否不等于给定的值
public Criteria andSubTitleNotEqualTo(String value) {
addCriterion("sub_title <>", value, "subTitle");
return (Criteria) this;
}
// 检查sub_title字段是否大于给定的值
public Criteria andSubTitleGreaterThan(String value) {
addCriterion("sub_title >", value, "subTitle");
return (Criteria) this;
}
// 检查sub_title字段是否大于或等于给定的值
public Criteria andSubTitleGreaterThanOrEqualTo(String value) {
addCriterion("sub_title >=", value, "subTitle");
return (Criteria) this;
}
// 检查sub_title字段是否小于给定的值
public Criteria andSubTitleLessThan(String value) {
addCriterion("sub_title <", value, "subTitle");
return (Criteria) this;
}
// 检查sub_title字段是否小于或等于给定的值
public Criteria andSubTitleLessThanOrEqualTo(String value) {
addCriterion("sub_title <=", value, "subTitle");
return (Criteria) this;
}
// 检查sub_title字段是否包含给定的值模糊匹配
public Criteria andSubTitleLike(String value) {
addCriterion("sub_title like", value, "subTitle");
return (Criteria) this;
}
// 检查sub_title字段是否不包含给定的值模糊匹配
public Criteria andSubTitleNotLike(String value) {
addCriterion("sub_title not like", value, "subTitle");
return (Criteria) this;
}
// 检查sub_title字段是否在给定的值列表中
public Criteria andSubTitleIn(List<String> values) {
addCriterion("sub_title in", values, "subTitle");
return (Criteria) this;
}
// 检查sub_title字段是否不在给定的值列表中
public Criteria andSubTitleNotIn(List<String> values) {
addCriterion("sub_title not in", values, "subTitle");
return (Criteria) this;
}
// 检查sub_title字段是否在给定的两个值之间
public Criteria andSubTitleBetween(String value1, String value2) {
addCriterion("sub_title between", value1, value2, "subTitle");
return (Criteria) this;
}
// 检查sub_title字段是否不在给定的两个值之间
public Criteria andSubTitleNotBetween(String value1, String value2) {
addCriterion("sub_title not between", value1, value2, "subTitle");
return (Criteria) this;
}
// 检查sort字段是否为空
public Criteria andSortIsNull() {
addCriterion("sort is null");
return (Criteria) this;
}
// 检查sort字段是否不为空
public Criteria andSortIsNotNull() {
addCriterion("sort is not null");
return (Criteria) this;
}
// 检查sort字段是否等于给定的值
public Criteria andSortEqualTo(Integer value) {
addCriterion("sort =", value, "sort");
return (Criteria) this;
}
// 检查sort字段是否不等于给定的值
public Criteria andSortNotEqualTo(Integer value) {
addCriterion("sort <>", value, "sort");
return (Criteria) this;
}
// 检查sort字段是否大于给定的值
public Criteria andSortGreaterThan(Integer value) {
addCriterion("sort >", value, "sort");
return (Criteria) this;
}
// 检查sort字段是否大于或等于给定的值
public Criteria andSortGreaterThanOrEqualTo(Integer value) {
addCriterion("sort >=", value, "sort");
return (Criteria) this;
}
// 检查sort字段是否小于给定的值
public Criteria andSortLessThan(Integer value) {
addCriterion("sort <", value, "sort");
return (Criteria) this;
}
// 检查sort字段是否小于或等于给定的值
public Criteria andSortLessThanOrEqualTo(Integer value) {
addCriterion("sort <=", value, "sort");
return (Criteria) this;
}
// 检查sort字段是否在给定的值列表中
public Criteria andSortIn(List<Integer> values) {
addCriterion("sort in", values, "sort");
return (Criteria) this;
}
// 检查sort字段是否不在给定的值列表中
public Criteria andSortNotIn(List<Integer> values) {
addCriterion("sort not in", values, "sort");
return (Criteria) this;
}
// 检查sort字段是否在给定的两个值之间
public Criteria andSortBetween(Integer value1, Integer value2) {
addCriterion("sort between", value1, value2, "sort");
return (Criteria) this;
}
// 检查sort字段是否不在给定的两个值之间
public Criteria andSortNotBetween(Integer value1, Integer value2) {
addCriterion("sort not between", value1, value2, "sort");
return (Criteria) this;
}
// 检查show_status字段是否为空
public Criteria andShowStatusIsNull() {
addCriterion("show_status is null");
return (Criteria) this;
}
// 检查show_status字段是否不为空
public Criteria andShowStatusIsNotNull() {
addCriterion("show_status is not null");
return (Criteria) this;
}
// 检查show_status字段是否等于给定的值
public Criteria andShowStatusEqualTo(Integer value) {
addCriterion("show_status =", value, "showStatus");
return (Criteria) this;
}
// 检查show_status字段是否不等于给定的值
public Criteria andShowStatusNotEqualTo(Integer value) {
addCriterion("show_status <>", value, "showStatus");
return (Criteria) this;
}
// 检查show_status字段是否大于给定的值
public Criteria andShowStatusGreaterThan(Integer value) {
addCriterion("show_status >", value, "showStatus");
return (Criteria) this;
}
// 检查show_status字段是否大于或等于给定的值
public Criteria andShowStatusGreaterThanOrEqualTo(Integer value) {
addCriterion("show_status >=", value, "showStatus");
return (Criteria) this;
}
// 检查show_status字段是否小于给定的值
public Criteria andShowStatusLessThan(Integer value) {
addCriterion("show_status <", value, "showStatus");
return (Criteria) this;
}
// 检查show_status字段是否小于或等于给定的值
public Criteria andShowStatusLessThanOrEqualTo(Integer value) {
addCriterion("show_status <=", value, "showStatus");
return (Criteria) this;
}
public Criteria andShowStatusIn(List<Integer> values) {
// 添加条件show_status 在指定的值列表中
addCriterion("show_status in", values, "showStatus");
return (Criteria) this;
}
public Criteria andShowStatusNotIn(List<Integer> values) {
// 添加条件show_status 不在指定的值列表中
addCriterion("show_status not in", values, "showStatus");
return (Criteria) this;
}
public Criteria andShowStatusBetween(Integer value1, Integer value2) {
// 添加条件show_status 在指定的两个值之间(包含边界)
addCriterion("show_status between", value1, value2, "showStatus");
return (Criteria) this;
}
public Criteria andShowStatusNotBetween(Integer value1, Integer value2) {
// 添加条件show_status 不在指定的两个值之间(不包含边界)
addCriterion("show_status not between", value1, value2, "showStatus");
return (Criteria) this;
}
}
public static class Criteria extends GeneratedCriteria {
// 构造函数初始化Criteria对象
protected Criteria() {
super();
}
}
public static class Criterion {
private String condition; // 条件表达式
private Object value; // 条件对应的值
private Object secondValue; // 第二个值用于between查询
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; // 如果值为列表则设置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);
}
}
}

@ -1,87 +0,0 @@
package com.macro.mall.model;
import io.swagger.annotations.ApiModelProperty;
import java.io.Serializable;
/**
*
*/
public class CmsPrefrenceAreaProductRelation implements Serializable {
// 主键ID
private Long id;
// 优选区域ID
private Long prefrenceAreaId;
// 商品ID
private Long productId;
// 序列化版本号,用于反序列化时验证版本一致性
private static final long serialVersionUID = 1L;
/**
* ID
* @return ID
*/
public Long getId() {
return id;
}
/**
* ID
* @param id ID
*/
public void setId(Long id) {
this.id = id;
}
/**
* ID
* @return ID
*/
public Long getPrefrenceAreaId() {
return prefrenceAreaId;
}
/**
* ID
* @param prefrenceAreaId ID
*/
public void setPrefrenceAreaId(Long prefrenceAreaId) {
this.prefrenceAreaId = prefrenceAreaId;
}
/**
* ID
* @return ID
*/
public Long getProductId() {
return productId;
}
/**
* ID
* @param productId ID
*/
public void setProductId(Long productId) {
this.productId = productId;
}
/**
*
* @return
*/
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append(getClass().getSimpleName());
sb.append(" [");
sb.append("Hash = ").append(hashCode());
sb.append(", id=").append(id);
sb.append(", prefrenceAreaId=").append(prefrenceAreaId);
sb.append(", productId=").append(productId);
sb.append(", serialVersionUID=").append(serialVersionUID);
sb.append("]");
return sb.toString();
}
}

@ -1,447 +0,0 @@
package com.macro.mall.model;
import java.util.ArrayList;
import java.util.List;
public class CmsPrefrenceAreaProductRelationExample {
// 定义排序子句
protected String orderByClause;
// 是否去重
protected boolean distinct;
// 存储查询条件列表
protected List<Criteria> oredCriteria;
// 构造函数,初始化查询条件列表
public CmsPrefrenceAreaProductRelationExample() {
oredCriteria = new ArrayList<>();
}
// 设置排序子句
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;
// 构造函数初始化criteria列表
protected GeneratedCriteria() {
super();
criteria = new ArrayList<>();
}
// 判断是否有有效的查询条件
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));
}
// 以下方法用于生成具体的查询条件例如id是否为空、id等于某个值等
public Criteria andIdIsNull() {
addCriterion("id is null");
return (Criteria) this;
}
public Criteria andIdIsNotNull() {
addCriterion("id is not null");
return (Criteria) this;
}
public Criteria andIdEqualTo(Long value) {
addCriterion("id =", value, "id");
return (Criteria) this;
}
public Criteria andIdNotEqualTo(Long value) {
addCriterion("id <>", value, "id");
return (Criteria) this;
}
public Criteria andIdGreaterThan(Long value) {
addCriterion("id >", value, "id");
return (Criteria) this;
}
public Criteria andIdGreaterThanOrEqualTo(Long value) {
addCriterion("id >=", value, "id");
return (Criteria) this;
}
public Criteria andIdLessThan(Long value) {
addCriterion("id <", value, "id");
return (Criteria) this;
}
public Criteria andIdLessThanOrEqualTo(Long value) {
addCriterion("id <=", value, "id");
return (Criteria) this;
}
public Criteria andIdIn(List<Long> values) {
addCriterion("id in", values, "id");
return (Criteria) this;
}
public Criteria andIdNotIn(List<Long> values) {
addCriterion("id not in", values, "id");
return (Criteria) this;
}
public Criteria andIdBetween(Long value1, Long value2) {
addCriterion("id between", value1, value2, "id");
return (Criteria) this;
}
public Criteria andIdNotBetween(Long value1, Long value2) {
addCriterion("id not between", value1, value2, "id");
return (Criteria) this;
}
// 以下方法用于生成prefrence_area_id相关的查询条件
public Criteria andPrefrenceAreaIdIsNull() {
addCriterion("prefrence_area_id is null");
return (Criteria) this;
}
public Criteria andPrefrenceAreaIdIsNotNull() {
addCriterion("prefrence_area_id is not null");
return (Criteria) this;
}
public Criteria andPrefrenceAreaIdEqualTo(Long value) {
addCriterion("prefrence_area_id =", value, "prefrenceAreaId");
return (Criteria) this;
}
public Criteria andPrefrenceAreaIdNotEqualTo(Long value) {
addCriterion("prefrence_area_id <>", value, "prefrenceAreaId");
return (Criteria) this;
}
public Criteria andPrefrenceAreaIdGreaterThan(Long value) {
addCriterion("prefrence_area_id >", value, "prefrenceAreaId");
return (Criteria) this;
}
public Criteria andPrefrenceAreaIdGreaterThanOrEqualTo(Long value) {
addCriterion("prefrence_area_id >=", value, "prefrenceAreaId");
return (Criteria) this;
}
public Criteria andPrefrenceAreaIdLessThan(Long value) {
addCriterion("prefrence_area_id <", value, "prefrenceAreaId");
return (Criteria) this;
}
public Criteria andPrefrenceAreaIdLessThanOrEqualTo(Long value) {
addCriterion("prefrence_area_id <=", value, "prefrenceAreaId");
return (Criteria) this;
}
public Criteria andPrefrenceAreaIdIn(List<Long> values) {
addCriterion("prefrence_area_id in", values, "prefrenceAreaId");
return (Criteria) this;
}
public Criteria andPrefrenceAreaIdNotIn(List<Long> values) {
addCriterion("prefrence_area_id not in", values, "prefrenceAreaId");
return (Criteria) this;
}
public Criteria andPrefrenceAreaIdBetween(Long value1, Long value2) {
addCriterion("prefrence_area_id between", value1, value2, "prefrenceAreaId");
return (Criteria) this;
}
public Criteria andPrefrenceAreaIdNotBetween(Long value1, Long value2) {
addCriterion("prefrence_area_id not between", value1, value2, "prefrenceAreaId");
return (Criteria) this;
}
// 以下方法用于生成product_id相关的查询条件
public Criteria andProductIdIsNull() {
addCriterion("product_id is null");
return (Criteria) this;
}
public Criteria andProductIdIsNotNull() {
addCriterion("product_id is not null");
return (Criteria) this;
}
public Criteria andProductIdEqualTo(Long value) {
addCriterion("product_id =", value, "productId");
return (Criteria) this;
}
public Criteria andProductIdNotEqualTo(Long value) {
addCriterion("product_id <>", value, "productId");
return (Criteria) this;
}
public Criteria andProductIdGreaterThan(Long value) {
addCriterion("product_id >", value, "productId");
return (Criteria) this;
}
public Criteria andProductIdGreaterThanOrEqualTo(Long value) {
addCriterion("product_id >=", value, "productId");
return (Criteria) this;
}
public Criteria andProductIdLessThan(Long value) {
addCriterion("product_id <", value, "productId");
return (Criteria) this;
}
/**
* product_id
*
* @param value
* @return Criteria
*/
public Criteria andProductIdLessThanOrEqualTo(Long value) {
addCriterion("product_id <=", value, "productId");
return (Criteria) this;
}
/**
* product_id
*
* @param values
* @return Criteria
*/
public Criteria andProductIdIn(List<Long> values) {
addCriterion("product_id in", values, "productId");
return (Criteria) this;
}
/**
* product_id
*
* @param values
* @return Criteria
*/
public Criteria andProductIdNotIn(List<Long> values) {
addCriterion("product_id not in", values, "productId");
return (Criteria) this;
}
/**
* product_id
*
* @param value1
* @param value2
* @return Criteria
*/
public Criteria andProductIdBetween(Long value1, Long value2) {
addCriterion("product_id between", value1, value2, "productId");
return (Criteria) this;
}
/**
* product_id
*
* @param value1
* @param value2
* @return Criteria
*/
public Criteria andProductIdNotBetween(Long value1, Long value2) {
addCriterion("product_id not between", value1, value2, "productId");
return (Criteria) this;
}
}
public static class Criteria extends GeneratedCriteria {
// 构造函数初始化Criteria对象
protected Criteria() {
super();
}
}
public static class Criterion {
private String condition; // 条件表达式
private Object value; // 条件值
private Object secondValue; // 第二个条件值用于between查询
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; // 如果值为列表则设置listValue为true
} else {
this.singleValue = true; // 否则设置为单一值
}
}
// 构造函数,包含条件表达式和值
protected Criterion(String condition, Object value) {
this(condition, value, null); // 调用另一个构造函数并传递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); // 调用另一个构造函数并传递null作为类型处理器
}
}
}

@ -1,246 +0,0 @@
package com.macro.mall.model;
import io.swagger.annotations.ApiModelProperty;
import java.io.Serializable;
import java.util.Date;
public class CmsSubject implements Serializable {
private Long id;
private Long categoryId;
private String title;
@ApiModelProperty(value = "专题主图")
private String pic;
@ApiModelProperty(value = "关联产品数量")
private Integer productCount;
private Integer recommendStatus;
private Date createTime;
private Integer collectCount;
private Integer readCount;
private Integer commentCount;
@ApiModelProperty(value = "画册图片用逗号分割")
private String albumPics;
private String description;
@ApiModelProperty(value = "显示状态0->不显示1->显示")
private Integer showStatus;
@ApiModelProperty(value = "转发数")
private Integer forwardCount;
@ApiModelProperty(value = "专题分类名称")
private String categoryName;
private String content;
private static final long serialVersionUID = 1L;
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public Long getCategoryId() {
return categoryId;
}
public void setCategoryId(Long categoryId) {
this.categoryId = categoryId;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public String getPic() {
return pic;
}
public void setPic(String pic) {
this.pic = pic;
}
public Integer getProductCount() {
return productCount;
}
public void setProductCount(Integer productCount) {
this.productCount = productCount;
}
public Integer getRecommendStatus() {
return recommendStatus;
}
public void setRecommendStatus(Integer recommendStatus) {
this.recommendStatus = recommendStatus;
}
public Date getCreateTime() {
return createTime;
}
public void setCreateTime(Date createTime) {
this.createTime = createTime;
}
public Integer getCollectCount() {
return collectCount;
}
public void setCollectCount(Integer collectCount) {
this.collectCount = collectCount;
}
public Integer getReadCount() {
return readCount;
}
public void setReadCount(Integer readCount) {
this.readCount = readCount;
}
public Integer getCommentCount() {
return commentCount;
}
public void setCommentCount(Integer commentCount) {
this.commentCount = commentCount;
}
public String getAlbumPics() {
return albumPics;
}
public void setAlbumPics(String albumPics) {
this.albumPics = albumPics;
}
public String getDescription() {
return description;
}
public void setDescription(String description) {
this.description = description;
}
public Integer getShowStatus() {
return showStatus;
}
public void setShowStatus(Integer showStatus) {
this.showStatus = showStatus;
}
public Integer getForwardCount() {
return forwardCount;
}
public void setForwardCount(Integer forwardCount) {
this.forwardCount = forwardCount;
}
public String getCategoryName() {
return categoryName;
}
public void setCategoryName(String categoryName) {
this.categoryName = categoryName;
}
public String getContent() {
return content;
}
public void setContent(String content) {
this.content = content;
}
@Override
public String toString() {
// 创建一个StringBuilder对象用于构建字符串
StringBuilder sb = new StringBuilder();
// 添加类的简单名称到StringBuilder中
sb.append(getClass().getSimpleName());
// 添加一个左方括号
sb.append(" [");
// 添加对象的哈希码到StringBuilder中
sb.append("Hash = ").append(hashCode());
// 添加id字段的值到StringBuilder中
sb.append(", id=").append(id);
// 添加categoryId字段的值到StringBuilder中
sb.append(", categoryId=").append(categoryId);
// 添加title字段的值到StringBuilder中
sb.append(", title=").append(title);
// 添加pic字段的值到StringBuilder中
sb.append(", pic=").append(pic);
// 添加productCount字段的值到StringBuilder中
sb.append(", productCount=").append(productCount);
// 添加recommendStatus字段的值到StringBuilder中
sb.append(", recommendStatus=").append(recommendStatus);
// 添加createTime字段的值到StringBuilder中
sb.append(", createTime=").append(createTime);
// 添加collectCount字段的值到StringBuilder中
sb.append(", collectCount=").append(collectCount);
// 添加readCount字段的值到StringBuilder中
sb.append(", readCount=").append(readCount);
// 添加commentCount字段的值到StringBuilder中
sb.append(", commentCount=").append(commentCount);
// 添加albumPics字段的值到StringBuilder中
sb.append(", albumPics=").append(albumPics);
// 添加description字段的值到StringBuilder中
sb.append(", description=").append(description);
// 添加showStatus字段的值到StringBuilder中
sb.append(", showStatus=").append(showStatus);
// 添加forwardCount字段的值到StringBuilder中
sb.append(", forwardCount=").append(forwardCount);
// 添加categoryName字段的值到StringBuilder中
sb.append(", categoryName=").append(categoryName);
// 添加content字段的值到StringBuilder中
sb.append(", content=").append(content);
// 添加serialVersionUID字段的值到StringBuilder中
sb.append(", serialVersionUID=").append(serialVersionUID);
// 添加右方括号并返回最终的字符串
sb.append("]");
return sb.toString();
}
}

@ -1,99 +0,0 @@
package com.macro.mall.model;
import io.swagger.annotations.ApiModelProperty;
import java.io.Serializable;
/**
*
*/
public class CmsSubjectCategory implements Serializable {
private Long id;
// 分类ID
private String name;
// 分类名称
@ApiModelProperty(value = "分类图标")
private String icon;
// 分类图标
@ApiModelProperty(value = "专题数量")
private Integer subjectCount;
// 专题数量
private Integer showStatus;
// 显示状态0->不显示1->显示
private Integer sort;
// 排序
private static final long serialVersionUID = 1L;
// 序列化版本号
// Getter和Setter方法
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getIcon() {
return icon;
}
public void setIcon(String icon) {
this.icon = icon;
}
public Integer getSubjectCount() {
return subjectCount;
}
public void setSubjectCount(Integer subjectCount) {
this.subjectCount = subjectCount;
}
public Integer getShowStatus() {
return showStatus;
}
public void setShowStatus(Integer showStatus) {
this.showStatus = showStatus;
}
public Integer getSort() {
return sort;
}
public void setSort(Integer sort) {
this.sort = sort;
}
// 重写toString方法用于打印对象信息
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append(getClass().getSimpleName());
sb.append(" [");
sb.append("Hash = ").append(hashCode());
sb.append(", id=").append(id);
sb.append(", name=").append(name);
sb.append(", icon=").append(icon);
sb.append(", subjectCount=").append(subjectCount);
sb.append(", showStatus=").append(showStatus);
sb.append(", sort=").append(sort);
sb.append(", serialVersionUID=").append(serialVersionUID);
sb.append("]");
return sb.toString();
}
}

@ -1,697 +0,0 @@
package com.macro.mall.model;
import java.util.ArrayList;
import java.util.List;
public class CmsSubjectCategoryExample {
// 定义一个用于排序的子句
protected String orderByClause;
// 定义一个布尔值,用于指示查询是否使用 DISTINCT 关键字
protected boolean distinct;
// 定义一个 Criteria 对象的列表,用于存储查询条件
protected List<Criteria> oredCriteria;
// 构造函数,初始化 oredCriteria 列表
public CmsSubjectCategoryExample() {
oredCriteria = new ArrayList<>();
}
// 设置排序子句的方法
public void setOrderByClause(String orderByClause) {
this.orderByClause = orderByClause;
}
// 获取排序子句的方法
public String getOrderByClause() {
return orderByClause;
}
// 设置是否使用 DISTINCT 关键字的方法
public void setDistinct(boolean distinct) {
this.distinct = distinct;
}
// 获取是否使用 DISTINCT 关键字的方法
public boolean isDistinct() {
return distinct;
}
// 获取 Criteria 对象列表的方法
public List<Criteria> getOredCriteria() {
return oredCriteria;
}
// 将一个 Criteria 对象添加到 oredCriteria 列表中的方法
public void or(Criteria criteria) {
oredCriteria.add(criteria);
}
// 创建一个新的 Criteria 对象并添加到 oredCriteria 列表中的方法
public Criteria or() {
Criteria criteria = createCriteriaInternal();
oredCriteria.add(criteria);
return criteria;
}
// 创建一个新的 Criteria 对象,如果 oredCriteria 列表为空则将其添加到列表中的方法
public Criteria createCriteria() {
Criteria criteria = createCriteriaInternal();
if (oredCriteria.size() == 0) {
oredCriteria.add(criteria);
}
return criteria;
}
// 内部方法,用于创建一个新的 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;
// 构造函数初始化criteria列表
protected GeneratedCriteria() {
super();
criteria = new ArrayList<>();
}
// 检查是否有有效的查询条件
public boolean isValid() {
return criteria.size() > 0;
}
// 获取所有的查询条件
public List<Criterion> getAllCriteria() {
return criteria;
}
// 获取当前的查询条件列表
public List<Criterion> getCriteria() {
return criteria;
}
// 添加一个简单的查询条件(例如 "id is null"
protected void addCriterion(String condition) {
if (condition == null) {
throw new RuntimeException("Value for condition cannot be null");
}
criteria.add(new Criterion(condition));
}
// 添加一个带值的查询条件(例如 "id = 1"
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));
}
// 添加一个范围查询条件(例如 "id between 1 and 10"
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 和 name 的条件判断
public Criteria andIdIsNull() {
addCriterion("id is null");
return (Criteria) this;
}
public Criteria andIdIsNotNull() {
addCriterion("id is not null");
return (Criteria) this;
}
public Criteria andIdEqualTo(Long value) {
addCriterion("id =", value, "id");
return (Criteria) this;
}
public Criteria andIdNotEqualTo(Long value) {
addCriterion("id <>", value, "id");
return (Criteria) this;
}
public Criteria andIdGreaterThan(Long value) {
addCriterion("id >", value, "id");
return (Criteria) this;
}
public Criteria andIdGreaterThanOrEqualTo(Long value) {
addCriterion("id >=", value, "id");
return (Criteria) this;
}
public Criteria andIdLessThan(Long value) {
addCriterion("id <", value, "id");
return (Criteria) this;
}
public Criteria andIdLessThanOrEqualTo(Long value) {
addCriterion("id <=", value, "id");
return (Criteria) this;
}
public Criteria andIdIn(List<Long> values) {
addCriterion("id in", values, "id");
return (Criteria) this;
}
public Criteria andIdNotIn(List<Long> values) {
addCriterion("id not in", values, "id");
return (Criteria) this;
}
public Criteria andIdBetween(Long value1, Long value2) {
addCriterion("id between", value1, value2, "id");
return (Criteria) this;
}
public Criteria andIdNotBetween(Long value1, Long value2) {
addCriterion("id not between", value1, value2, "id");
return (Criteria) this;
}
public Criteria andNameIsNull() {
addCriterion("name is null");
return (Criteria) this;
}
public Criteria andNameIsNotNull() {
addCriterion("name is not null");
return (Criteria) this;
}
public Criteria andNameEqualTo(String value) {
addCriterion("name =", value, "name");
return (Criteria) this;
}
public Criteria andNameNotEqualTo(String value) {
addCriterion("name <>", value, "name");
return (Criteria) this;
}
public Criteria andNameGreaterThan(String value) {
addCriterion("name >", value, "name");
return (Criteria) this;
}
public Criteria andNameGreaterThanOrEqualTo(String value) {
addCriterion("name >=", value, "name");
return (Criteria) this;
}
public Criteria andNameLessThan(String value) {
addCriterion("name <", value, "name");
return (Criteria) this;
}
public Criteria andNameLessThanOrEqualTo(String value) {
addCriterion("name <=", value, "name");
return (Criteria) this;
}
public Criteria andNameLike(String value) {
addCriterion("name like", value, "name");
return (Criteria) this;
}
public Criteria andNameNotLike(String value) {
addCriterion("name not like", value, "name");
return (Criteria) this;
}
public Criteria andNameIn(List<String> values) {
addCriterion("name in", values, "name");
return (Criteria) this;
}
public Criteria andNameNotIn(List<String> values) {
addCriterion("name not in", values, "name");
return (Criteria) this;
}
public Criteria andNameBetween(String value1, String value2) {
addCriterion("name between", value1, value2, "name");
return (Criteria) this;
}
public Criteria andNameNotBetween(String value1, String value2) {
addCriterion("name not between", value1, value2, "name");
return (Criteria) this;
}
public Criteria andIconIsNull() {
addCriterion("icon is null");
return (Criteria) this;
}
public Criteria andIconIsNotNull() {
addCriterion("icon is not null");
return (Criteria) this;
}
public Criteria andIconEqualTo(String value) {
addCriterion("icon =", value, "icon");
return (Criteria) this;
}
public Criteria andIconNotEqualTo(String value) {
addCriterion("icon <>", value, "icon");
return (Criteria) this;
}
// 检查icon字段是否大于给定值
public Criteria andIconGreaterThan(String value) {
addCriterion("icon >", value, "icon");
return (Criteria) this;
}
// 检查icon字段是否大于或等于给定值
public Criteria andIconGreaterThanOrEqualTo(String value) {
addCriterion("icon >=", value, "icon");
return (Criteria) this;
}
// 检查icon字段是否小于给定值
public Criteria andIconLessThan(String value) {
addCriterion("icon <", value, "icon");
return (Criteria) this;
}
// 检查icon字段是否小于或等于给定值
public Criteria andIconLessThanOrEqualTo(String value) {
addCriterion("icon <=", value, "icon");
return (Criteria) this;
}
// 检查icon字段是否匹配给定的模式使用SQL的LIKE操作符
public Criteria andIconLike(String value) {
addCriterion("icon like", value, "icon");
return (Criteria) this;
}
// 检查icon字段是否不匹配给定的模式使用SQL的NOT LIKE操作符
public Criteria andIconNotLike(String value) {
addCriterion("icon not like", value, "icon");
return (Criteria) this;
}
// 检查icon字段是否在给定的值列表中
public Criteria andIconIn(List<String> values) {
addCriterion("icon in", values, "icon");
return (Criteria) this;
}
// 检查icon字段是否不在给定的值列表中
public Criteria andIconNotIn(List<String> values) {
addCriterion("icon not in", values, "icon");
return (Criteria) this;
}
// 检查icon字段是否在给定的两个值之间
public Criteria andIconBetween(String value1, String value2) {
addCriterion("icon between", value1, value2, "icon");
return (Criteria) this;
}
// 检查icon字段是否不在给定的两个值之间
public Criteria andIconNotBetween(String value1, String value2) {
addCriterion("icon not between", value1, value2, "icon");
return (Criteria) this;
}
// 检查subject_count字段是否为空
public Criteria andSubjectCountIsNull() {
addCriterion("subject_count is null");
return (Criteria) this;
}
// 检查subject_count字段是否不为空
public Criteria andSubjectCountIsNotNull() {
addCriterion("subject_count is not null");
return (Criteria) this;
}
// 检查subject_count字段是否等于给定值
public Criteria andSubjectCountEqualTo(Integer value) {
addCriterion("subject_count =", value, "subjectCount");
return (Criteria) this;
}
// 检查subject_count字段是否不等于给定值
public Criteria andSubjectCountNotEqualTo(Integer value) {
addCriterion("subject_count <>", value, "subjectCount");
return (Criteria) this;
}
// 检查subject_count字段是否大于给定值
public Criteria andSubjectCountGreaterThan(Integer value) {
addCriterion("subject_count >", value, "subjectCount");
return (Criteria) this;
}
// 检查subject_count字段是否大于或等于给定值
public Criteria andSubjectCountGreaterThanOrEqualTo(Integer value) {
addCriterion("subject_count >=", value, "subjectCount");
return (Criteria) this;
}
// 检查subject_count字段是否小于给定值
public Criteria andSubjectCountLessThan(Integer value) {
addCriterion("subject_count <", value, "subjectCount");
return (Criteria) this;
}
// 检查subject_count字段是否小于或等于给定值
public Criteria andSubjectCountLessThanOrEqualTo(Integer value) {
addCriterion("subject_count <=", value, "subjectCount");
return (Criteria) this;
}
// 检查subject_count字段是否在给定的值列表中
public Criteria andSubjectCountIn(List<Integer> values) {
addCriterion("subject_count in", values, "subjectCount");
return (Criteria) this;
}
// 检查subject_count字段是否不在给定的值列表中
public Criteria andSubjectCountNotIn(List<Integer> values) {
addCriterion("subject_count not in", values, "subjectCount");
return (Criteria) this;
}
// 检查subject_count字段是否在给定的两个值之间
public Criteria andSubjectCountBetween(Integer value1, Integer value2) {
addCriterion("subject_count between", value1, value2, "subjectCount");
return (Criteria) this;
}
// 检查subject_count字段是否不在给定的两个值之间
public Criteria andSubjectCountNotBetween(Integer value1, Integer value2) {
addCriterion("subject_count not between", value1, value2, "subjectCount");
return (Criteria) this;
}
// 检查show_status字段是否为空
public Criteria andShowStatusIsNull() {
addCriterion("show_status is null");
return (Criteria) this;
}
// 检查show_status字段是否不为空
public Criteria andShowStatusIsNotNull() {
addCriterion("show_status is not null");
return (Criteria) this;
}
// 检查show_status字段是否等于给定值
public Criteria andShowStatusEqualTo(Integer value) {
addCriterion("show_status =", value, "showStatus");
return (Criteria) this;
}
// 检查show_status字段是否不等于给定值
public Criteria andShowStatusNotEqualTo(Integer value) {
addCriterion("show_status <>", value, "showStatus");
return (Criteria) this;
}
// 检查show_status字段是否大于给定值
public Criteria andShowStatusGreaterThan(Integer value) {
addCriterion("show_status >", value, "showStatus");
return (Criteria) this;
}
// 检查show_status字段是否大于或等于给定值
public Criteria andShowStatusGreaterThanOrEqualTo(Integer value) {
addCriterion("show_status >=", value, "showStatus");
return (Criteria) this;
}
// 检查show_status字段是否小于给定值
public Criteria andShowStatusLessThan(Integer value) {
addCriterion("show_status <", value, "showStatus");
return (Criteria) this;
}
// 检查show_status字段是否小于或等于给定值
public Criteria andShowStatusLessThanOrEqualTo(Integer value) {
addCriterion("show_status <=", value, "showStatus");
return (Criteria) this;
}
// 检查show_status字段是否在给定的值列表中
public Criteria andShowStatusIn(List<Integer> values) {
addCriterion("show_status in", values, "showStatus");
return (Criteria) this;
}
// 检查show_status字段是否不在给定的值列表中
public Criteria andShowStatusNotIn(List<Integer> values) {
addCriterion("show_status not in", values, "showStatus");
return (Criteria) this;
}
// 检查show_status字段是否在给定的两个值之间
public Criteria andShowStatusBetween(Integer value1, Integer value2) {
addCriterion("show_status between", value1, value2, "showStatus");
return (Criteria) this;
}
// 检查show_status字段是否不在给定的两个值之间
public Criteria andShowStatusNotBetween(Integer value1, Integer value2) {
addCriterion("show_status not between", value1, value2, "showStatus");
return (Criteria) this;
}
// 检查sort字段是否为空
public Criteria andSortIsNull() {
addCriterion("sort is null");
return (Criteria) this;
}
// 检查sort字段是否不为空
public Criteria andSortIsNotNull() {
addCriterion("sort is not null");
return (Criteria) this;
}
// 检查sort字段是否等于给定值
public Criteria andSortEqualTo(Integer value) {
addCriterion("sort =", value, "sort");
return (Criteria) this;
}
// 检查sort字段是否不等于给定值
public Criteria andSortNotEqualTo(Integer value) {
addCriterion("sort <>", value, "sort");
return (Criteria) this;
}
// 检查sort字段是否大于给定值
public Criteria andSortGreaterThan(Integer value) {
addCriterion("sort >", value, "sort");
return (Criteria) this;
}
/**
* 'sort'
*
* @param value
* @return Criteria
*/
public Criteria andSortGreaterThanOrEqualTo(Integer value) {
addCriterion("sort >=", value, "sort");
return (Criteria) this;
}
/**
* 'sort'
*
* @param value
* @return Criteria
*/
public Criteria andSortLessThan(Integer value) {
addCriterion("sort <", value, "sort");
return (Criteria) this;
}
/**
* 'sort'
*
* @param value
* @return Criteria
*/
public Criteria andSortLessThanOrEqualTo(Integer value) {
addCriterion("sort <=", value, "sort");
return (Criteria) this;
}
/**
* 'sort'
*
* @param values
* @return Criteria
*/
public Criteria andSortIn(List<Integer> values) {
addCriterion("sort in", values, "sort");
return (Criteria) this;
}
/**
* 'sort'
*
* @param values
* @return Criteria
*/
public Criteria andSortNotIn(List<Integer> values) {
addCriterion("sort not in", values, "sort");
return (Criteria) this;
}
/**
* 'sort'
*
* @param value1
* @param value2
* @return Criteria
*/
public Criteria andSortBetween(Integer value1, Integer value2) {
addCriterion("sort between", value1, value2, "sort");
return (Criteria) this;
}
/**
* 'sort'
*
* @param value1
* @param value2
* @return Criteria
*/
public Criteria andSortNotBetween(Integer value1, Integer value2) {
addCriterion("sort not between", value1, value2, "sort");
return (Criteria) this;
}
}
public static class Criteria extends GeneratedCriteria {
// 构造函数初始化Criteria对象
protected Criteria() {
super();
}
}
public static class Criterion {
private String condition; // 条件表达式
private Object value; // 条件对应的值
private Object secondValue; // 第二个值用于between查询
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; // 如果值为列表则设置listValue为true
} else {
this.singleValue = true; // 否则设置为单一值
}
}
// 构造函数,包含条件表达式和值
protected Criterion(String condition, Object value) {
this(condition, value, null); // 调用另一个构造函数并传递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); // 调用另一个构造函数并传递null作为类型处理器
}
}
}

@ -1,100 +0,0 @@
package com.macro.mall.model; // 定义包名
import io.swagger.annotations.ApiModelProperty; // 导入Swagger注解库
import java.io.Serializable; // 导入序列化接口
import java.util.Date; // 导入日期类
// 定义CmsSubjectComment类实现Serializable接口
public class CmsSubjectComment implements Serializable {
private Long id; // 评论ID
private Long subjectId; // 专题ID
private String memberNickName; // 会员昵称
private String memberIcon; // 会员头像
private String content; // 评论内容
private Date createTime; // 创建时间
private Integer showStatus; // 显示状态
private static final long serialVersionUID = 1L; // 序列化版本号
// Getter和Setter方法
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public Long getSubjectId() {
return subjectId;
}
public void setSubjectId(Long subjectId) {
this.subjectId = subjectId;
}
public String getMemberNickName() {
return memberNickName;
}
public void setMemberNickName(String memberNickName) {
this.memberNickName = memberNickName;
}
public String getMemberIcon() {
return memberIcon;
}
public void setMemberIcon(String memberIcon) {
this.memberIcon = memberIcon;
}
public String getContent() {
return content;
}
public void setContent(String content) {
this.content = content;
}
public Date getCreateTime() {
return createTime;
}
public void setCreateTime(Date createTime) {
this.createTime = createTime;
}
public Integer getShowStatus() {
return showStatus;
}
public void setShowStatus(Integer showStatus) {
this.showStatus = showStatus;
}
// 重写toString方法用于打印对象信息
@Override
public String toString() {
StringBuilder sb = new StringBuilder(); // 创建StringBuilder对象
sb.append(getClass().getSimpleName()); // 添加类名
sb.append(" ["); // 添加左方括号
sb.append("Hash = ").append(hashCode()); // 添加哈希码
sb.append(", id=").append(id); // 添加ID
sb.append(", subjectId=").append(subjectId); // 添加专题ID
sb.append(", memberNickName=").append(memberNickName); // 添加会员昵称
sb.append(", memberIcon=").append(memberIcon); // 添加会员头像
sb.append(", content=").append(content); // 添加评论内容
sb.append(", createTime=").append(createTime); // 添加创建时间
sb.append(", showStatus=").append(showStatus); // 添加显示状态
sb.append(", serialVersionUID=").append(serialVersionUID); // 添加序列化版本号
sb.append("]"); // 添加右方括号
return sb.toString(); // 返回字符串表示形式
}
}

@ -1,770 +0,0 @@
package com.macro.mall.model;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
public class CmsSubjectCommentExample {
// 用于存储排序子句的字符串
protected String orderByClause;
// 用于指示查询是否为distinct去重
protected boolean distinct;
// 用于存储多个查询条件的列表
protected List<Criteria> oredCriteria;
// 构造函数初始化oredCriteria为一个空的ArrayList
public CmsSubjectCommentExample() {
oredCriteria = new ArrayList<>();
}
// 设置排序子句的方法
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;
}
// 将一个Criteria对象添加到查询条件列表中的方法
public void or(Criteria criteria) {
oredCriteria.add(criteria);
}
// 创建一个新的Criteria对象并添加到查询条件列表中的方法
public Criteria or() {
Criteria criteria = createCriteriaInternal();
oredCriteria.add(criteria);
return criteria;
}
// 创建一个Criteria对象如果查询条件列表为空则将其添加到列表中的方法
public Criteria createCriteria() {
Criteria criteria = createCriteriaInternal();
if (oredCriteria.size() == 0) {
oredCriteria.add(criteria);
}
return criteria;
}
// 内部方法用于创建一个新的Criteria对象
protected Criteria createCriteriaInternal() {
Criteria criteria = new Criteria();
return criteria;
}
// 清除所有查询条件和排序子句并将distinct设置为false的方法
public void clear() {
oredCriteria.clear();
orderByClause = null;
distinct = false;
}
protected abstract static class GeneratedCriteria {
// 定义一个受保护的列表,用于存储查询条件
protected List<Criterion> criteria;
// 构造函数初始化criteria为一个新的ArrayList
protected GeneratedCriteria() {
super();
criteria = new ArrayList<>();
}
// 判断是否有有效的查询条件
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));
}
// 添加一个带两个值的查询条件用于BETWEEN查询
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、subjectId和memberNickName等字段的条件
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(Long value) {
addCriterion("id =", value, "id");
return (Criteria) this;
}
// 检查id是否不等于指定值
public Criteria andIdNotEqualTo(Long value) {
addCriterion("id <>", value, "id");
return (Criteria) this;
}
// 检查id是否大于指定值
public Criteria andIdGreaterThan(Long value) {
addCriterion("id >", value, "id");
return (Criteria) this;
}
// 检查id是否大于或等于指定值
public Criteria andIdGreaterThanOrEqualTo(Long value) {
addCriterion("id >=", value, "id");
return (Criteria) this;
}
// 检查id是否小于指定值
public Criteria andIdLessThan(Long value) {
addCriterion("id <", value, "id");
return (Criteria) this;
}
// 检查id是否小于或等于指定值
public Criteria andIdLessThanOrEqualTo(Long value) {
addCriterion("id <=", value, "id");
return (Criteria) this;
}
// 检查id是否在指定的列表中
public Criteria andIdIn(List<Long> values) {
addCriterion("id in", values, "id");
return (Criteria) this;
}
// 检查id是否不在指定的列表中
public Criteria andIdNotIn(List<Long> values) {
addCriterion("id not in", values, "id");
return (Criteria) this;
}
// 检查id是否在指定的范围内包含边界
public Criteria andIdBetween(Long value1, Long value2) {
addCriterion("id between", value1, value2, "id");
return (Criteria) this;
}
// 检查id是否不在指定的范围内不包含边界
public Criteria andIdNotBetween(Long value1, Long value2) {
addCriterion("id not between", value1, value2, "id");
return (Criteria) this;
}
// 检查subject_id是否为空
public Criteria andSubjectIdIsNull() {
addCriterion("subject_id is null");
return (Criteria) this;
}
// 检查subject_id是否不为空
public Criteria andSubjectIdIsNotNull() {
addCriterion("subject_id is not null");
return (Criteria) this;
}
// 检查subject_id是否等于指定值
public Criteria andSubjectIdEqualTo(Long value) {
addCriterion("subject_id =", value, "subjectId");
return (Criteria) this;
}
// 检查subject_id是否不等于指定值
public Criteria andSubjectIdNotEqualTo(Long value) {
addCriterion("subject_id <>", value, "subjectId");
return (Criteria) this;
}
// 检查subject_id是否大于指定值
public Criteria andSubjectIdGreaterThan(Long value) {
addCriterion("subject_id >", value, "subjectId");
return (Criteria) this;
}
// 检查subject_id是否大于或等于指定值
public Criteria andSubjectIdGreaterThanOrEqualTo(Long value) {
addCriterion("subject_id >=", value, "subjectId");
return (Criteria) this;
}
// 检查subject_id是否小于指定值
public Criteria andSubjectIdLessThan(Long value) {
addCriterion("subject_id <", value, "subjectId");
return (Criteria) this;
}
// 检查subject_id是否小于或等于指定值
public Criteria andSubjectIdLessThanOrEqualTo(Long value) {
addCriterion("subject_id <=", value, "subjectId");
return (Criteria) this;
}
// 检查subject_id是否在指定的列表中
public Criteria andSubjectIdIn(List<Long> values) {
addCriterion("subject_id in", values, "subjectId");
return (Criteria) this;
}
// 检查subject_id是否不在指定的列表中
public Criteria andSubjectIdNotIn(List<Long> values) {
addCriterion("subject_id not in", values, "subjectId");
return (Criteria) this;
}
// 检查subject_id是否在指定的范围内包含边界
public Criteria andSubjectIdBetween(Long value1, Long value2) {
addCriterion("subject_id between", value1, value2, "subjectId");
return (Criteria) this;
}
// 检查subject_id是否不在指定的范围内不包含边界
public Criteria andSubjectIdNotBetween(Long value1, Long value2) {
addCriterion("subject_id not between", value1, value2, "subjectId");
return (Criteria) this;
}
// 检查member_nick_name是否为空
public Criteria andMemberNickNameIsNull() {
addCriterion("member_nick_name is null");
return (Criteria) this;
}
// 检查member_nick_name是否不为空
public Criteria andMemberNickNameIsNotNull() {
addCriterion("member_nick_name is not null");
return (Criteria) this;
}
// 检查member_nick_name是否等于指定值
public Criteria andMemberNickNameEqualTo(String value) {
addCriterion("member_nick_name =", value, "memberNickName");
return (Criteria) this;
}
// 检查member_nick_name是否不等于指定值
public Criteria andMemberNickNameNotEqualTo(String value) {
addCriterion("member_nick_name <>", value, "memberNickName");
return (Criteria) this;
}
// 检查member_nick_name是否大于指定值
public Criteria andMemberNickNameGreaterThan(String value) {
addCriterion("member_nick_name >", value, "memberNickName");
return (Criteria) this;
}
// 检查member_nick_name是否大于或等于指定值
public Criteria andMemberNickNameGreaterThanOrEqualTo(String value) {
addCriterion("member_nick_name >=", value, "memberNickName");
return (Criteria) this;
}
// 检查member_nick_name是否小于指定值
public Criteria andMemberNickNameLessThan(String value) {
addCriterion("member_nick_name <", value, "memberNickName");
return (Criteria) this;
}
// 检查 member_nick_name 是否小于或等于给定的值
public Criteria andMemberNickNameLessThanOrEqualTo(String value) {
addCriterion("member_nick_name <=", value, "memberNickName");
return (Criteria) this;
}
// 检查 member_nick_name 是否包含给定的值(模糊匹配)
public Criteria andMemberNickNameLike(String value) {
addCriterion("member_nick_name like", value, "memberNickName");
return (Criteria) this;
}
// 检查 member_nick_name 是否不包含给定的值(模糊匹配)
public Criteria andMemberNickNameNotLike(String value) {
addCriterion("member_nick_name not like", value, "memberNickName");
return (Criteria) this;
}
// 检查 member_nick_name 是否在给定的值列表中
public Criteria andMemberNickNameIn(List<String> values) {
addCriterion("member_nick_name in", values, "memberNickName");
return (Criteria) this;
}
// 检查 member_nick_name 是否不在给定的值列表中
public Criteria andMemberNickNameNotIn(List<String> values) {
addCriterion("member_nick_name not in", values, "memberNickName");
return (Criteria) this;
}
// 检查 member_nick_name 是否在给定的两个值之间
public Criteria andMemberNickNameBetween(String value1, String value2) {
addCriterion("member_nick_name between", value1, value2, "memberNickName");
return (Criteria) this;
}
// 检查 member_nick_name 是否不在给定的两个值之间
public Criteria andMemberNickNameNotBetween(String value1, String value2) {
addCriterion("member_nick_name not between", value1, value2, "memberNickName");
return (Criteria) this;
}
// 检查 member_icon 是否为空
public Criteria andMemberIconIsNull() {
addCriterion("member_icon is null");
return (Criteria) this;
}
// 检查 member_icon 是否不为空
public Criteria andMemberIconIsNotNull() {
addCriterion("member_icon is not null");
return (Criteria) this;
}
// 检查 member_icon 是否等于给定的值
public Criteria andMemberIconEqualTo(String value) {
addCriterion("member_icon =", value, "memberIcon");
return (Criteria) this;
}
// 检查 member_icon 是否不等于给定的值
public Criteria andMemberIconNotEqualTo(String value) {
addCriterion("member_icon <>", value, "memberIcon");
return (Criteria) this;
}
// 检查 member_icon 是否大于给定的值
public Criteria andMemberIconGreaterThan(String value) {
addCriterion("member_icon >", value, "memberIcon");
return (Criteria) this;
}
// 检查 member_icon 是否大于或等于给定的值
public Criteria andMemberIconGreaterThanOrEqualTo(String value) {
addCriterion("member_icon >=", value, "memberIcon");
return (Criteria) this;
}
// 检查 member_icon 是否小于给定的值
public Criteria andMemberIconLessThan(String value) {
addCriterion("member_icon <", value, "memberIcon");
return (Criteria) this;
}
// 检查 member_icon 是否小于或等于给定的值
public Criteria andMemberIconLessThanOrEqualTo(String value) {
addCriterion("member_icon <=", value, "memberIcon");
return (Criteria) this;
}
// 检查 member_icon 是否包含给定的值(模糊匹配)
public Criteria andMemberIconLike(String value) {
addCriterion("member_icon like", value, "memberIcon");
return (Criteria) this;
}
// 检查 member_icon 是否不包含给定的值(模糊匹配)
public Criteria andMemberIconNotLike(String value) {
addCriterion("member_icon not like", value, "memberIcon");
return (Criteria) this;
}
// 检查 member_icon 是否在给定的值列表中
public Criteria andMemberIconIn(List<String> values) {
addCriterion("member_icon in", values, "memberIcon");
return (Criteria) this;
}
// 检查 member_icon 是否不在给定的值列表中
public Criteria andMemberIconNotIn(List<String> values) {
addCriterion("member_icon not in", values, "memberIcon");
return (Criteria) this;
}
// 检查 member_icon 是否在给定的两个值之间
public Criteria andMemberIconBetween(String value1, String value2) {
addCriterion("member_icon between", value1, value2, "memberIcon");
return (Criteria) this;
}
// 检查 member_icon 是否不在给定的两个值之间
public Criteria andMemberIconNotBetween(String value1, String value2) {
addCriterion("member_icon not between", value1, value2, "memberIcon");
return (Criteria) this;
}
// 检查 content 是否为空
public Criteria andContentIsNull() {
addCriterion("content is null");
return (Criteria) this;
}
// 检查 content 是否不为空
public Criteria andContentIsNotNull() {
addCriterion("content is not null");
return (Criteria) this;
}
// 检查 content 是否等于给定的值
public Criteria andContentEqualTo(String value) {
addCriterion("content =", value, "content");
return (Criteria) this;
}
// 检查 content 是否不等于给定的值
public Criteria andContentNotEqualTo(String value) {
addCriterion("content <>", value, "content");
return (Criteria) this;
}
// 检查 content 是否大于给定的值
public Criteria andContentGreaterThan(String value) {
addCriterion("content >", value, "content");
return (Criteria) this;
}
// 检查 content 是否大于或等于给定的值
public Criteria andContentGreaterThanOrEqualTo(String value) {
addCriterion("content >=", value, "content");
return (Criteria) this;
}
// 检查 content 是否小于给定的值
public Criteria andContentLessThan(String value) {
addCriterion("content <", value, "content");
return (Criteria) this;
}
// 检查 content 是否小于或等于给定的值
public Criteria andContentLessThanOrEqualTo(String value) {
addCriterion("content <=", value, "content");
return (Criteria) this;
}
// 检查 content 是否包含给定的值(模糊匹配)
public Criteria andContentLike(String value) {
addCriterion("content like", value, "content");
return (Criteria) this;
}
// 检查 content 是否不包含给定的值(模糊匹配)
public Criteria andContentNotLike(String value) {
addCriterion("content not like", value, "content");
return (Criteria) this;
}
// 检查 content 是否在给定的值列表中
public Criteria andContentIn(List<String> values) {
addCriterion("content in", values, "content");
return (Criteria) this;
}
// 检查 content 是否不在给定的值列表中
public Criteria andContentNotIn(List<String> values) {
addCriterion("content not in", values, "content");
return (Criteria) this;
}
// 检查 content 是否在给定的两个值之间
public Criteria andContentBetween(String value1, String value2) {
addCriterion("content between", value1, value2, "content");
return (Criteria) this;
}
// 检查 content 是否不在给定的两个值之间
public Criteria andContentNotBetween(String value1, String value2) {
addCriterion("content not between", value1, value2, "content");
return (Criteria) this;
}
// 检查 create_time 是否不为空
public Criteria andCreateTimeIsNotNull() {
addCriterion("create_time is not null");
return (Criteria) this;
}
// 检查 create_time 是否等于给定的值
public Criteria andCreateTimeEqualTo(Date value) {
addCriterion("create_time =", value, "createTime");
return (Criteria) this;
}
// 检查 create_time 是否不等于给定的值
public Criteria andCreateTimeNotEqualTo(Date value) {
addCriterion("create_time <>", value, "createTime");
return (Criteria) this;
}
// 检查 create_time 是否大于给定的值
public Criteria andCreateTimeGreaterThan(Date value) {
addCriterion("create_time >", value, "createTime");
return (Criteria) this;
}
// 检查 create_time 是否大于或等于给定的值
public Criteria andCreateTimeGreaterThanOrEqualTo(Date value) {
addCriterion("create_time >=", value, "createTime");
return (Criteria) this;
}
// 检查 create_time 是否小于给定的值
public Criteria andCreateTimeLessThan(Date value) {
addCriterion("create_time <", value, "createTime");
return (Criteria) this;
}
// 检查 create_time 是否小于或等于给定的值
public Criteria andCreateTimeLessThanOrEqualTo(Date value) {
addCriterion("create_time <=", value, "createTime");
return (Criteria) this;
}
// 检查 create_time 是否在给定的值列表中
public Criteria andCreateTimeIn(List<Date> values) {
addCriterion("create_time in", values, "createTime");
return (Criteria) this;
}
// 检查 create_time 是否不在给定的值列表中
public Criteria andCreateTimeNotIn(List<Date> values) {
addCriterion("create_time not in", values, "createTime");
return (Criteria) this;
}
// 检查 create_time 是否在给定的两个值之间
public Criteria andCreateTimeBetween(Date value1, Date value2) {
addCriterion("create_time between", value1, value2, "createTime");
return (Criteria) this;
}
// 检查 create_time 是否不在给定的两个值之间
public Criteria andCreateTimeNotBetween(Date value1, Date value2) {
addCriterion("create_time not between", value1, value2, "createTime");
return (Criteria) this;
}
// 检查 show_status 是否为空
public Criteria andShowStatusIsNull() {
addCriterion("show_status is null");
return (Criteria) this;
}
// 检查 show_status 是否不为空
public Criteria andShowStatusIsNotNull() {
addCriterion("show_status is not null");
return (Criteria) this;
}
// 检查 show_status 是否等于给定的值
public Criteria andShowStatusEqualTo(Integer value) {
addCriterion("show_status =", value, "showStatus");
return (Criteria) this;
}
// 检查 show_status 是否不等于给定的值
public Criteria andShowStatusNotEqualTo(Integer value) {
addCriterion("show_status <>", value, "showStatus");
return (Criteria) this;
}
// 检查 show_status 是否大于给定的值
public Criteria andShowStatusGreaterThan(Integer value) {
addCriterion("show_status >", value, "showStatus");
return (Criteria) this;
}
// 检查 show_status 是否大于或等于给定的值
public Criteria andShowStatusGreaterThanOrEqualTo(Integer value) {
addCriterion("show_status >=", value, "showStatus");
return (Criteria) this;
}
// 检查 show_status 是否小于给定的值
public Criteria andShowStatusLessThan(Integer value) {
addCriterion("show_status <", value, "showStatus");
return (Criteria) this;
}
// 检查 show_status 是否小于或等于给定的值
public Criteria andShowStatusLessThanOrEqualTo(Integer value) {
addCriterion("show_status <=", value, "showStatus");
return (Criteria) this;
}
// 检查 show_status 是否在给定的值列表中
public Criteria andShowStatusIn(List<Integer> values) {
addCriterion("show_status in", values, "showStatus");
return (Criteria) this;
}
// 检查 show_status 是否不在给定的值列表中
public Criteria andShowStatusNotIn(List<Integer> values) {
addCriterion("show_status not in", values, "showStatus");
return (Criteria) this;
}
// 检查 show_status 是否在给定的两个值之间
public Criteria andShowStatusBetween(Integer value1, Integer value2) {
addCriterion("show_status between", value1, value2, "showStatus");
return (Criteria) this;
}
// 检查 show_status 是否不在给定的两个值之间
public Criteria andShowStatusNotBetween(Integer value1, Integer value2) {
addCriterion("show_status not between", value1, value2, "showStatus");
return (Criteria) this;
}
}
// 定义一个静态内部类 Criteria继承自 GeneratedCriteria
public static class Criteria extends GeneratedCriteria {
// 构造函数,调用父类的构造函数
protected Criteria() {
super();
}
}
// 定义一个静态内部类 Criterion用于封装查询条件
public static class Criterion {
private String condition; // 存储查询条件的字符串
private Object value; // 存储查询条件的值
private Object secondValue; // 存储查询条件的第二个值(用于 between 查询)
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;
}
// 构造函数,只包含条件,默认没有值,使用 null 作为类型处理器
protected Criterion(String condition) {
super();
this.condition = condition;
this.typeHandler = null;
this.noValue = true;
}
// 构造函数,包含条件和值,根据值的类型设置 singleValue 或 listValue
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);
}
// 构造函数,包含条件、第一个值和第二个值,以及类型处理器,设置 betweenValue 为 true
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);
}
}
}

@ -1,72 +0,0 @@
package com.macro.mall.model;
import io.swagger.annotations.ApiModelProperty;
import java.io.Serializable;
public class CmsSubjectProductRelation implements Serializable {
private Long id;
private Long subjectId;
private Long productId;
private static final long serialVersionUID = 1L;
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public Long getSubjectId() {
return subjectId;
}
public void setSubjectId(Long subjectId) {
this.subjectId = subjectId;
}
public Long getProductId() {
return productId;
}
public void setProductId(Long productId) {
this.productId = productId;
}
@Override
public String toString() {
// 创建一个StringBuilder对象用于构建字符串
StringBuilder sb = new StringBuilder();
// 获取当前类的简单名称并追加到StringBuilder中
sb.append(getClass().getSimpleName());
// 追加一个左方括号
sb.append(" [");
// 追加当前对象的哈希码
sb.append("Hash = ").append(hashCode());
// 追加id字段的值
sb.append(", id=").append(id);
// 追加subjectId字段的值
sb.append(", subjectId=").append(subjectId);
// 追加productId字段的值
sb.append(", productId=").append(productId);
// 追加serialVersionUID字段的值
sb.append(", serialVersionUID=").append(serialVersionUID);
// 追加右方括号
sb.append("]");
// 将StringBuilder转换为字符串并返回
return sb.toString();
}
}

@ -1,424 +0,0 @@
package com.macro.mall.model;
import java.util.ArrayList;
import java.util.List;
public class CmsSubjectProductRelationExample {
// 定义排序子句
protected String orderByClause;
// 是否使用 DISTINCT 关键字
protected boolean distinct;
// 存储查询条件的列表
protected List<Criteria> oredCriteria;
// 构造函数,初始化查询条件列表
public CmsSubjectProductRelationExample() {
oredCriteria = new ArrayList<>();
}
// 设置排序子句
public void setOrderByClause(String orderByClause) {
this.orderByClause = orderByClause;
}
// 获取排序子句
public String getOrderByClause() {
return orderByClause;
}
// 设置是否使用 DISTINCT 关键字
public void setDistinct(boolean distinct) {
this.distinct = distinct;
}
// 判断是否使用 DISTINCT 关键字
public boolean isDistinct() {
return distinct;
}
// 获取查询条件列表
public List<Criteria> getOredCriteria() {
return oredCriteria;
}
// 添加一个查询条件到列表中
public void or(Criteria criteria) {
oredCriteria.add(criteria);
}
// 创建一个新的 Criteria 对象并添加到查询条件列表中
public Criteria or() {
Criteria criteria = createCriteriaInternal();
oredCriteria.add(criteria);
return criteria;
}
// 创建一个 Criteria 对象,如果查询条件列表为空则添加到列表中
public Criteria createCriteria() {
Criteria criteria = createCriteriaInternal();
if (oredCriteria.size() == 0) {
oredCriteria.add(criteria);
}
return criteria;
}
// 内部方法,用于创建一个新的 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;
// 构造函数初始化criteria列表
protected GeneratedCriteria() {
super();
criteria = new ArrayList<>();
}
// 检查是否有任何查询条件
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));
}
// 以下方法用于生成具体的查询条件例如id是否为空、id等于某个值等
public Criteria andIdIsNull() {
addCriterion("id is null");
return (Criteria) this;
}
public Criteria andIdIsNotNull() {
addCriterion("id is not null");
return (Criteria) this;
}
public Criteria andIdEqualTo(Long value) {
addCriterion("id =", value, "id");
return (Criteria) this;
}
public Criteria andIdNotEqualTo(Long value) {
addCriterion("id <>", value, "id");
return (Criteria) this;
}
public Criteria andIdGreaterThan(Long value) {
addCriterion("id >", value, "id");
return (Criteria) this;
}
public Criteria andIdGreaterThanOrEqualTo(Long value) {
addCriterion("id >=", value, "id");
return (Criteria) this;
}
public Criteria andIdLessThan(Long value) {
addCriterion("id <", value, "id");
return (Criteria) this;
}
public Criteria andIdLessThanOrEqualTo(Long value) {
addCriterion("id <=", value, "id");
return (Criteria) this;
}
public Criteria andIdIn(List<Long> values) {
addCriterion("id in", values, "id");
return (Criteria) this;
}
public Criteria andIdNotIn(List<Long> values) {
addCriterion("id not in", values, "id");
return (Criteria) this;
}
public Criteria andIdBetween(Long value1, Long value2) {
addCriterion("id between", value1, value2, "id");
return (Criteria) this;
}
public Criteria andIdNotBetween(Long value1, Long value2) {
addCriterion("id not between", value1, value2, "id");
return (Criteria) this;
}
// 以下方法用于生成subject_id相关的查询条件
public Criteria andSubjectIdIsNull() {
addCriterion("subject_id is null");
return (Criteria) this;
}
public Criteria andSubjectIdIsNotNull() {
addCriterion("subject_id is not null");
return (Criteria) this;
}
public Criteria andSubjectIdEqualTo(Long value) {
addCriterion("subject_id =", value, "subjectId");
return (Criteria) this;
}
public Criteria andSubjectIdNotEqualTo(Long value) {
addCriterion("subject_id <>", value, "subjectId");
return (Criteria) this;
}
public Criteria andSubjectIdGreaterThan(Long value) {
addCriterion("subject_id >", value, "subjectId");
return (Criteria) this;
}
public Criteria andSubjectIdGreaterThanOrEqualTo(Long value) {
addCriterion("subject_id >=", value, "subjectId");
return (Criteria) this;
}
public Criteria andSubjectIdLessThan(Long value) {
addCriterion("subject_id <", value, "subjectId");
return (Criteria) this;
}
public Criteria andSubjectIdLessThanOrEqualTo(Long value) {
addCriterion("subject_id <=", value, "subjectId");
return (Criteria) this;
}
public Criteria andSubjectIdIn(List<Long> values) {
addCriterion("subject_id in", values, "subjectId");
return (Criteria) this;
}
public Criteria andSubjectIdNotIn(List<Long> values) {
addCriterion("subject_id not in", values, "subjectId");
return (Criteria) this;
}
public Criteria andSubjectIdBetween(Long value1, Long value2) {
addCriterion("subject_id between", value1, value2, "subjectId");
return (Criteria) this;
}
public Criteria andSubjectIdNotBetween(Long value1, Long value2) {
addCriterion("subject_id not between", value1, value2, "subjectId");
return (Criteria) this;
}
// 以下方法用于生成product_id相关的查询条件
public Criteria andProductIdIsNull() {
addCriterion("product_id is null");
return (Criteria) this;
}
public Criteria andProductIdIsNotNull() {
addCriterion("product_id is not null");
return (Criteria) this;
}
public Criteria andProductIdEqualTo(Long value) {
addCriterion("product_id =", value, "productId");
return (Criteria) this;
}
// 检查 product_id 是否不等于指定的值
public Criteria andProductIdNotEqualTo(Long value) {
addCriterion("product_id <>", value, "productId");
return (Criteria) this;
}
// 检查 product_id 是否大于指定的值
public Criteria andProductIdGreaterThan(Long value) {
addCriterion("product_id >", value, "productId");
return (Criteria) this;
}
// 检查 product_id 是否大于或等于指定的值
public Criteria andProductIdGreaterThanOrEqualTo(Long value) {
addCriterion("product_id >=", value, "productId");
return (Criteria) this;
}
// 检查 product_id 是否小于指定的值
public Criteria andProductIdLessThan(Long value) {
addCriterion("product_id <", value, "productId");
return (Criteria) this;
}
// 检查 product_id 是否小于或等于指定的值
public Criteria andProductIdLessThanOrEqualTo(Long value) {
addCriterion("product_id <=", value, "productId");
return (Criteria) this;
}
// 检查 product_id 是否在指定的值列表中
public Criteria andProductIdIn(List<Long> values) {
addCriterion("product_id in", values, "productId");
return (Criteria) this;
}
// 检查 product_id 是否不在指定的值列表中
public Criteria andProductIdNotIn(List<Long> values) {
addCriterion("product_id not in", values, "productId");
return (Criteria) this;
}
// 检查 product_id 是否在指定的两个值之间(包含边界)
public Criteria andProductIdBetween(Long value1, Long value2) {
addCriterion("product_id between", value1, value2, "productId");
return (Criteria) this;
}
// 检查 product_id 是否不在指定的两个值之间(不包含边界)
public Criteria andProductIdNotBetween(Long value1, Long value2) {
addCriterion("product_id not between", value1, value2, "productId");
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; // 第二个值用于between查询
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); // 调用另一个构造函数,并传递 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); // 调用另一个构造函数,并传递 null 作为类型处理器
}
}
}

@ -1,161 +0,0 @@
package com.macro.mall.model;
import io.swagger.annotations.ApiModelProperty;
import java.io.Serializable;
import java.util.Date;
/**
*
*/
public class CmsTopic implements Serializable {
private Long id; // 话题的唯一标识符
private Long categoryId; // 话题所属分类的ID
private String name; // 话题的名称
private Date createTime; // 话题的创建时间
private Date startTime; // 话题的开始时间
private Date endTime; // 话题的结束时间
@ApiModelProperty(value = "参与人数")
private Integer attendCount; // 参与该话题的人数
@ApiModelProperty(value = "关注人数")
private Integer attentionCount; // 关注该话题的人数
private Integer readCount; // 阅读该话题的次数
@ApiModelProperty(value = "奖品名称")
private String awardName; // 与该话题相关的奖品名称
@ApiModelProperty(value = "参与方式")
private String attendType; // 参与该话题的方式
@ApiModelProperty(value = "话题内容")
private String content; // 话题的具体内容
private static final long serialVersionUID = 1L; // 序列化版本号
// Getter和Setter方法
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public Long getCategoryId() {
return categoryId;
}
public void setCategoryId(Long categoryId) {
this.categoryId = categoryId;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Date getCreateTime() {
return createTime;
}
public void setCreateTime(Date createTime) {
this.createTime = createTime;
}
public Date getStartTime() {
return startTime;
}
public void setStartTime(Date startTime) {
this.startTime = startTime;
}
public Date getEndTime() {
return endTime;
}
public void setEndTime(Date endTime) {
this.endTime = endTime;
}
public Integer getAttendCount() {
return attendCount;
}
public void setAttendCount(Integer attendCount) {
this.attendCount = attendCount;
}
public Integer getAttentionCount() {
return attentionCount;
}
public void setAttentionCount(Integer attentionCount) {
this.attentionCount = attentionCount;
}
public Integer getReadCount() {
return readCount;
}
public void setReadCount(Integer readCount) {
this.readCount = readCount;
}
public String getAwardName() {
return awardName;
}
public void setAwardName(String awardName) {
this.awardName = awardName;
}
public String getAttendType() {
return attendType;
}
public void setAttendType(String attendType) {
this.attendType = attendType;
}
public String getContent() {
return content;
}
public void setContent(String content) {
this.content = content;
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append(getClass().getSimpleName());
sb.append(" [");
sb.append("Hash = ").append(hashCode());
sb.append(", id=").append(id);
sb.append(", categoryId=").append(categoryId);
sb.append(", name=").append(name);
sb.append(", createTime=").append(createTime);
sb.append(", startTime=").append(startTime);
sb.append(", endTime=").append(endTime);
sb.append(", attendCount=").append(attendCount);
sb.append(", attentionCount=").append(attentionCount);
sb.append(", readCount=").append(readCount);
sb.append(", awardName=").append(awardName);
sb.append(", attendType=").append(attendType);
sb.append(", content=").append(content);
sb.append(", serialVersionUID=").append(serialVersionUID);
sb.append("]");
return sb.toString();
}
}

@ -1,91 +0,0 @@
package com.macro.mall.model;
import io.swagger.annotations.ApiModelProperty;
import java.io.Serializable;
/**
* CmsTopicCategory
*/
public class CmsTopicCategory implements Serializable {
private Long id; // 分类的唯一标识符
private String name; // 分类的名称
@ApiModelProperty(value = "分类图标")
private String icon; // 分类的图标URL
@ApiModelProperty(value = "专题数量")
private Integer subjectCount; // 该分类下的专题数量
private Integer showStatus; // 显示状态0不显示1显示
private Integer sort; // 排序字段
private static final long serialVersionUID = 1L; // 序列化版本号
// Getter和Setter方法
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getIcon() {
return icon;
}
public void setIcon(String icon) {
this.icon = icon;
}
public Integer getSubjectCount() {
return subjectCount;
}
public void setSubjectCount(Integer subjectCount) {
this.subjectCount = subjectCount;
}
public Integer getShowStatus() {
return showStatus;
}
public void setShowStatus(Integer showStatus) {
this.showStatus = showStatus;
}
public Integer getSort() {
return sort;
}
public void setSort(Integer sort) {
this.sort = sort;
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append(getClass().getSimpleName());
sb.append(" [");
sb.append("Hash = ").append(hashCode());
sb.append(", id=").append(id);
sb.append(", name=").append(name);
sb.append(", icon=").append(icon);
sb.append(", subjectCount=").append(subjectCount);
sb.append(", showStatus=").append(showStatus);
sb.append(", sort=").append(sort);
sb.append(", serialVersionUID=").append(serialVersionUID);
sb.append("]");
return sb.toString();
}
}

@ -1,664 +0,0 @@
package com.macro.mall.model;
import java.util.ArrayList;
import java.util.List;
public class CmsTopicCategoryExample {
// 定义一个用于排序的子句
protected String orderByClause;
// 定义一个布尔值,用于指示查询结果是否去重
protected boolean distinct;
// 定义一个列表用于存储查询条件Criteria
protected List<Criteria> oredCriteria;
// 构造函数初始化oredCriteria为一个新的ArrayList
public CmsTopicCategoryExample() {
oredCriteria = new ArrayList<>();
}
// 设置排序子句的方法
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;
}
// 添加一个查询条件到oredCriteria列表中的方法
public void or(Criteria criteria) {
oredCriteria.add(criteria);
}
// 创建一个新的Criteria对象并添加到oredCriteria列表中的方法
public Criteria or() {
Criteria criteria = createCriteriaInternal();
oredCriteria.add(criteria);
return criteria;
}
// 创建一个Criteria对象如果oredCriteria列表为空则将其添加到列表中的方法
public Criteria createCriteria() {
Criteria criteria = createCriteriaInternal();
if (oredCriteria.size() == 0) {
oredCriteria.add(criteria);
}
return criteria;
}
// 内部方法用于创建一个新的Criteria对象
protected Criteria createCriteriaInternal() {
Criteria criteria = new Criteria();
return criteria;
}
// 清除所有查询条件和排序子句并将distinct设置为false的方法
public void clear() {
oredCriteria.clear();
orderByClause = null;
distinct = false;
}
protected abstract static class GeneratedCriteria {
// 定义一个列表来存储所有的查询条件
protected List<Criterion> criteria;
// 构造函数初始化criteria列表
protected GeneratedCriteria() {
super();
criteria = new ArrayList<>();
}
// 判断是否有有效的查询条件
public boolean isValid() {
return criteria.size() > 0;
}
// 获取所有查询条件
public List<Criterion> getAllCriteria() {
return criteria;
}
// 获取当前查询条件列表
public List<Criterion> getCriteria() {
return criteria;
}
// 添加一个简单的查询条件(例如 "id is null"
protected void addCriterion(String condition) {
if (condition == null) {
throw new RuntimeException("Value for condition cannot be null");
}
criteria.add(new Criterion(condition));
}
// 添加一个带值的查询条件(例如 "id = 1"
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));
}
// 添加一个范围查询条件(例如 "id between 1 and 10"
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));
}
// 以下方法用于生成具体的查询条件并返回当前的Criteria对象以支持链式调用
public Criteria andIdIsNull() {
addCriterion("id is null");
return (Criteria) this;
}
public Criteria andIdIsNotNull() {
addCriterion("id is not null");
return (Criteria) this;
}
public Criteria andIdEqualTo(Long value) {
addCriterion("id =", value, "id");
return (Criteria) this;
}
public Criteria andIdNotEqualTo(Long value) {
addCriterion("id <>", value, "id");
return (Criteria) this;
}
public Criteria andIdGreaterThan(Long value) {
addCriterion("id >", value, "id");
return (Criteria) this;
}
public Criteria andIdGreaterThanOrEqualTo(Long value) {
addCriterion("id >=", value, "id");
return (Criteria) this;
}
public Criteria andIdLessThan(Long value) {
addCriterion("id <", value, "id");
return (Criteria) this;
}
public Criteria andIdLessThanOrEqualTo(Long value) {
addCriterion("id <=", value, "id");
return (Criteria) this;
}
public Criteria andIdIn(List<Long> values) {
addCriterion("id in", values, "id");
return (Criteria) this;
}
public Criteria andIdNotIn(List<Long> values) {
addCriterion("id not in", values, "id");
return (Criteria) this;
}
public Criteria andIdBetween(Long value1, Long value2) {
addCriterion("id between", value1, value2, "id");
return (Criteria) this;
}
public Criteria andIdNotBetween(Long value1, Long value2) {
addCriterion("id not between", value1, value2, "id");
return (Criteria) this;
}
public Criteria andNameIsNull() {
addCriterion("name is null");
return (Criteria) this;
}
public Criteria andNameIsNotNull() {
addCriterion("name is not null");
return (Criteria) this;
}
public Criteria andNameEqualTo(String value) {
addCriterion("name =", value, "name");
return (Criteria) this;
}
public Criteria andNameNotEqualTo(String value) {
addCriterion("name <>", value, "name");
return (Criteria) this;
}
public Criteria andNameGreaterThan(String value) {
addCriterion("name >", value, "name");
return (Criteria) this;
}
public Criteria andNameGreaterThanOrEqualTo(String value) {
addCriterion("name >=", value, "name");
return (Criteria) this;
}
public Criteria andNameLessThan(String value) {
addCriterion("name <", value, "name");
return (Criteria) this;
}
public Criteria andNameLessThanOrEqualTo(String value) {
addCriterion("name <=", value, "name");
return (Criteria) this;
}
public Criteria andNameLike(String value) {
addCriterion("name like", value, "name");
return (Criteria) this;
}
public Criteria andNameNotLike(String value) {
addCriterion("name not like", value, "name");
return (Criteria) this;
}
public Criteria andNameIn(List<String> values) {
addCriterion("name in", values, "name");
return (Criteria) this;
}
public Criteria andNameNotIn(List<String> values) {
addCriterion("name not in", values, "name");
return (Criteria) this;
}
public Criteria andNameBetween(String value1, String value2) {
addCriterion("name between", value1, value2, "name");
return (Criteria) this;
}
public Criteria andNameNotBetween(String value1, String value2) {
addCriterion("name not between", value1, value2, "name");
return (Criteria) this;
}
public Criteria andIconIsNull() {
addCriterion("icon is null");
return (Criteria) this;
}
// 检查icon字段是否不为空
public Criteria andIconIsNotNull() {
addCriterion("icon is not null");
return (Criteria) this;
}
// 检查icon字段是否等于指定值
public Criteria andIconEqualTo(String value) {
addCriterion("icon =", value, "icon");
return (Criteria) this;
}
// 检查icon字段是否不等于指定值
public Criteria andIconNotEqualTo(String value) {
addCriterion("icon <>", value, "icon");
return (Criteria) this;
}
// 检查icon字段是否大于指定值
public Criteria andIconGreaterThan(String value) {
addCriterion("icon >", value, "icon");
return (Criteria) this;
}
// 检查icon字段是否大于或等于指定值
public Criteria andIconGreaterThanOrEqualTo(String value) {
addCriterion("icon >=", value, "icon");
return (Criteria) this;
}
// 检查icon字段是否小于指定值
public Criteria andIconLessThan(String value) {
addCriterion("icon <", value, "icon");
return (Criteria) this;
}
// 检查icon字段是否小于或等于指定值
public Criteria andIconLessThanOrEqualTo(String value) {
addCriterion("icon <=", value, "icon");
return (Criteria) this;
}
// 检查icon字段是否匹配指定模式使用LIKE
public Criteria andIconLike(String value) {
addCriterion("icon like", value, "icon");
return (Criteria) this;
}
// 检查icon字段是否不匹配指定模式使用NOT LIKE
public Criteria andIconNotLike(String value) {
addCriterion("icon not like", value, "icon");
return (Criteria) this;
}
// 检查icon字段是否在指定的值列表中
public Criteria andIconIn(List<String> values) {
addCriterion("icon in", values, "icon");
return (Criteria) this;
}
// 检查icon字段是否不在指定的值列表中
public Criteria andIconNotIn(List<String> values) {
addCriterion("icon not in", values, "icon");
return (Criteria) this;
}
// 检查icon字段是否在指定的范围内between
public Criteria andIconBetween(String value1, String value2) {
addCriterion("icon between", value1, value2, "icon");
return (Criteria) this;
}
// 检查icon字段是否不在指定的范围内not between
public Criteria andIconNotBetween(String value1, String value2) {
addCriterion("icon not between", value1, value2, "icon");
return (Criteria) this;
}
// 检查subject_count字段是否为空
public Criteria andSubjectCountIsNull() {
addCriterion("subject_count is null");
return (Criteria) this;
}
// 检查subject_count字段是否不为空
public Criteria andSubjectCountIsNotNull() {
addCriterion("subject_count is not null");
return (Criteria) this;
}
// 检查subject_count字段是否等于指定值
public Criteria andSubjectCountEqualTo(Integer value) {
addCriterion("subject_count =", value, "subjectCount");
return (Criteria) this;
}
// 检查subject_count字段是否不等于指定值
public Criteria andSubjectCountNotEqualTo(Integer value) {
addCriterion("subject_count <>", value, "subjectCount");
return (Criteria) this;
}
// 检查subject_count字段是否大于指定值
public Criteria andSubjectCountGreaterThan(Integer value) {
addCriterion("subject_count >", value, "subjectCount");
return (Criteria) this;
}
// 检查subject_count字段是否大于或等于指定值
public Criteria andSubjectCountGreaterThanOrEqualTo(Integer value) {
addCriterion("subject_count >=", value, "subjectCount");
return (Criteria) this;
}
// 检查subject_count字段是否小于指定值
public Criteria andSubjectCountLessThan(Integer value) {
addCriterion("subject_count <", value, "subjectCount");
return (Criteria) this;
}
// 检查subject_count字段是否小于或等于指定值
public Criteria andSubjectCountLessThanOrEqualTo(Integer value) {
addCriterion("subject_count <=", value, "subjectCount");
return (Criteria) this;
}
// 检查subject_count字段是否在指定的值列表中
public Criteria andSubjectCountIn(List<Integer> values) {
addCriterion("subject_count in", values, "subjectCount");
return (Criteria) this;
}
// 检查subject_count字段是否不在指定的值列表中
public Criteria andSubjectCountNotIn(List<Integer> values) {
addCriterion("subject_count not in", values, "subjectCount");
return (Criteria) this;
}
// 检查subject_count字段是否在指定的范围内between
public Criteria andSubjectCountBetween(Integer value1, Integer value2) {
addCriterion("subject_count between", value1, value2, "subjectCount");
return (Criteria) this;
}
// 检查subject_count字段是否不在指定的范围内not between
public Criteria andSubjectCountNotBetween(Integer value1, Integer value2) {
addCriterion("subject_count not between", value1, value2, "subjectCount");
return (Criteria) this;
}
// 检查show_status字段是否为空
public Criteria andShowStatusIsNull() {
addCriterion("show_status is null");
return (Criteria) this;
}
// 检查show_status字段是否不为空
public Criteria andShowStatusIsNotNull() {
addCriterion("show_status is not null");
return (Criteria) this;
}
// 检查show_status字段是否等于指定值
public Criteria andShowStatusEqualTo(Integer value) {
addCriterion("show_status =", value, "showStatus");
return (Criteria) this;
}
// 检查show_status字段是否不等于指定值
public Criteria andShowStatusNotEqualTo(Integer value) {
addCriterion("show_status <>", value, "showStatus");
return (Criteria) this;
}
// 检查 show_status 是否大于指定值
public Criteria andShowStatusGreaterThan(Integer value) {
addCriterion("show_status >", value, "showStatus");
return (Criteria) this;
}
// 检查 show_status 是否大于或等于指定值
public Criteria andShowStatusGreaterThanOrEqualTo(Integer value) {
addCriterion("show_status >=", value, "showStatus");
return (Criteria) this;
}
// 检查 show_status 是否小于指定值
public Criteria andShowStatusLessThan(Integer value) {
addCriterion("show_status <", value, "showStatus");
return (Criteria) this;
}
// 检查 show_status 是否小于或等于指定值
public Criteria andShowStatusLessThanOrEqualTo(Integer value) {
addCriterion("show_status <=", value, "showStatus");
return (Criteria) this;
}
// 检查 show_status 是否在指定的值列表中
public Criteria andShowStatusIn(List<Integer> values) {
addCriterion("show_status in", values, "showStatus");
return (Criteria) this;
}
// 检查 show_status 是否不在指定的值列表中
public Criteria andShowStatusNotIn(List<Integer> values) {
addCriterion("show_status not in", values, "showStatus");
return (Criteria) this;
}
// 检查 show_status 是否在指定的范围内between
public Criteria andShowStatusBetween(Integer value1, Integer value2) {
addCriterion("show_status between", value1, value2, "showStatus");
return (Criteria) this;
}
// 检查 show_status 是否不在指定的范围内not between
public Criteria andShowStatusNotBetween(Integer value1, Integer value2) {
addCriterion("show_status not between", value1, value2, "showStatus");
return (Criteria) this;
}
// 检查 sort 是否为空
public Criteria andSortIsNull() {
addCriterion("sort is null");
return (Criteria) this;
}
// 检查 sort 是否不为空
public Criteria andSortIsNotNull() {
addCriterion("sort is not null");
return (Criteria) this;
}
// 检查 sort 是否等于指定值
public Criteria andSortEqualTo(Integer value) {
addCriterion("sort =", value, "sort");
return (Criteria) this;
}
// 检查 sort 是否不等于指定值
public Criteria andSortNotEqualTo(Integer value) {
addCriterion("sort <>", value, "sort");
return (Criteria) this;
}
// 检查 sort 是否大于指定值
public Criteria andSortGreaterThan(Integer value) {
addCriterion("sort >", value, "sort");
return (Criteria) this;
}
// 检查 sort 是否大于或等于指定值
public Criteria andSortGreaterThanOrEqualTo(Integer value) {
addCriterion("sort >=", value, "sort");
return (Criteria) this;
}
// 检查 sort 是否小于指定值
public Criteria andSortLessThan(Integer value) {
addCriterion("sort <", value, "sort");
return (Criteria) this;
}
// 检查 sort 是否小于或等于指定值
public Criteria andSortLessThanOrEqualTo(Integer value) {
addCriterion("sort <=", value, "sort");
return (Criteria) this;
}
// 检查 sort 是否在指定的值列表中
public Criteria andSortIn(List<Integer> values) {
addCriterion("sort in", values, "sort");
return (Criteria) this;
}
// 检查 sort 是否不在指定的值列表中
public Criteria andSortNotIn(List<Integer> values) {
addCriterion("sort not in", values, "sort");
return (Criteria) this;
}
// 检查 sort 是否在指定的范围内between
public Criteria andSortBetween(Integer value1, Integer value2) {
addCriterion("sort between", value1, value2, "sort");
return (Criteria) this;
}
// 检查 sort 是否不在指定的范围内not between
public Criteria andSortNotBetween(Integer value1, Integer value2) {
addCriterion("sort not between", value1, value2, "sort");
return (Criteria) this;
}
}
public static class Criteria extends GeneratedCriteria {
// 构造函数初始化Criteria对象
protected Criteria() {
super();
}
}
public static class Criterion {
private String condition; // 条件表达式
private Object value; // 条件值
private Object secondValue; // 第二个条件值用于between查询
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; // 如果值为列表则设置listValue为true
} else {
this.singleValue = true; // 否则设置为单一值
}
}
// 构造函数,包含条件表达式和值,不包含类型处理器
protected Criterion(String condition, Object value) {
this(condition, value, null);
}
// 构造函数包含条件表达式、两个值和可选的类型处理器用于between查询
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; // 设置为区间值
}
// 构造函数包含条件表达式、两个值不包含类型处理器用于between查询
protected Criterion(String condition, Object value, Object secondValue) {
this(condition, value, secondValue, null);
}
}
}

@ -1,108 +0,0 @@
package com.macro.mall.model;
import io.swagger.annotations.ApiModelProperty;
import java.io.Serializable;
import java.util.Date;
/**
* CmsTopicComment class represents a comment on a topic in the CMS (Content Management System).
*/
public class CmsTopicComment implements Serializable {
private Long id; // Unique identifier for the comment
@ApiModelProperty(value = "Nickname of the member who posted the comment")
private String memberNickName; // Nickname of the member who posted the comment
@ApiModelProperty(value = "ID of the topic to which this comment is related")
private Long topicId; // ID of the topic to which this comment is related
@ApiModelProperty(value = "Icon URL of the member who posted the comment")
private String memberIcon; // Icon URL of the member who posted the comment
@ApiModelProperty(value = "Content of the comment")
private String content; // Content of the comment
@ApiModelProperty(value = "Creation time of the comment")
private Date createTime; // Creation time of the comment
@ApiModelProperty(value = "Status indicating whether the comment is displayed or not")
private Integer showStatus; // Status indicating whether the comment is displayed or not
private static final long serialVersionUID = 1L; // Serial version UID for serialization
// Getters and Setters for each field
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getMemberNickName() {
return memberNickName;
}
public void setMemberNickName(String memberNickName) {
this.memberNickName = memberNickName;
}
public Long getTopicId() {
return topicId;
}
public void setTopicId(Long topicId) {
this.topicId = topicId;
}
public String getMemberIcon() {
return memberIcon;
}
public void setMemberIcon(String memberIcon) {
this.memberIcon = memberIcon;
}
public String getContent() {
return content;
}
public void setContent(String content) {
this.content = content;
}
public Date getCreateTime() {
return createTime;
}
public void setCreateTime(Date createTime) {
this.createTime = createTime;
}
public Integer getShowStatus() {
return showStatus;
}
public void setShowStatus(Integer showStatus) {
this.showStatus = showStatus;
}
// Overriding toString method to provide string representation of the object
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append(getClass().getSimpleName());
sb.append(" [");
sb.append("Hash = ").append(hashCode());
sb.append(", id=").append(id);
sb.append(", memberNickName=").append(memberNickName);
sb.append(", topicId=").append(topicId);
sb.append(", memberIcon=").append(memberIcon);
sb.append(", content=").append(content);
sb.append(", createTime=").append(createTime);
sb.append(", showStatus=").append(showStatus);
sb.append(", serialVersionUID=").append(serialVersionUID);
sb.append("]");
return sb.toString();
}
}

@ -1,743 +0,0 @@
package com.macro.mall.model;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
public class CmsTopicCommentExample {
// 定义一个用于排序的字符串
protected String orderByClause;
// 定义一个布尔值,表示查询结果是否去重
protected boolean distinct;
// 定义一个列表,用于存储查询条件
protected List<Criteria> oredCriteria;
// 构造函数初始化oredCriteria为一个新的ArrayList
public CmsTopicCommentExample() {
oredCriteria = new ArrayList<>();
}
// 设置排序子句的方法
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;
}
// 内部方法用于创建一个新的Criteria对象
protected Criteria createCriteriaInternal() {
Criteria criteria = new Criteria();
return criteria;
}
// 清除所有查询条件和排序子句的方法并将distinct设置为false
public void clear() {
oredCriteria.clear();
orderByClause = null;
distinct = false;
}
protected abstract static class GeneratedCriteria {
// 定义一个列表来存储所有的查询条件
protected List<Criterion> criteria;
// 构造函数初始化criteria列表
protected GeneratedCriteria() {
super();
criteria = new ArrayList<>();
}
// 判断是否有有效的查询条件
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));
}
// 以下是具体的查询条件方法,用于构建不同的查询条件
public Criteria andIdIsNull() {
addCriterion("id is null");
return (Criteria) this;
}
public Criteria andIdIsNotNull() {
addCriterion("id is not null");
return (Criteria) this;
}
public Criteria andIdEqualTo(Long value) {
addCriterion("id =", value, "id");
return (Criteria) this;
}
public Criteria andIdNotEqualTo(Long value) {
addCriterion("id <>", value, "id");
return (Criteria) this;
}
public Criteria andIdGreaterThan(Long value) {
addCriterion("id >", value, "id");
return (Criteria) this;
}
public Criteria andIdGreaterThanOrEqualTo(Long value) {
addCriterion("id >=", value, "id");
return (Criteria) this;
}
public Criteria andIdLessThan(Long value) {
addCriterion("id <", value, "id");
return (Criteria) this;
}
public Criteria andIdLessThanOrEqualTo(Long value) {
addCriterion("id <=", value, "id");
return (Criteria) this;
}
public Criteria andIdIn(List<Long> values) {
addCriterion("id in", values, "id");
return (Criteria) this;
}
public Criteria andIdNotIn(List<Long> values) {
addCriterion("id not in", values, "id");
return (Criteria) this;
}
public Criteria andIdBetween(Long value1, Long value2) {
addCriterion("id between", value1, value2, "id");
return (Criteria) this;
}
public Criteria andIdNotBetween(Long value1, Long value2) {
addCriterion("id not between", value1, value2, "id");
return (Criteria) this;
}
public Criteria andMemberNickNameIsNull() {
addCriterion("member_nick_name is null");
return (Criteria) this;
}
public Criteria andMemberNickNameIsNotNull() {
addCriterion("member_nick_name is not null");
return (Criteria) this;
}
public Criteria andMemberNickNameEqualTo(String value) {
addCriterion("member_nick_name =", value, "memberNickName");
return (Criteria) this;
}
public Criteria andMemberNickNameNotEqualTo(String value) {
addCriterion("member_nick_name <>", value, "memberNickName");
return (Criteria) this;
}
public Criteria andMemberNickNameGreaterThan(String value) {
addCriterion("member_nick_name >", value, "memberNickName");
return (Criteria) this;
}
public Criteria andMemberNickNameGreaterThanOrEqualTo(String value) {
addCriterion("member_nick_name >=", value, "memberNickName");
return (Criteria) this;
}
public Criteria andMemberNickNameLessThan(String value) {
addCriterion("member_nick_name <", value, "memberNickName");
return (Criteria) this;
}
public Criteria andMemberNickNameLessThanOrEqualTo(String value) {
addCriterion("member_nick_name <=", value, "memberNickName");
return (Criteria) this;
}
public Criteria andMemberNickNameLike(String value) {
addCriterion("member_nick_name like", value, "memberNickName");
return (Criteria) this;
}
public Criteria andMemberNickNameNotLike(String value) {
addCriterion("member_nick_name not like", value, "memberNickName");
return (Criteria) this;
}
public Criteria andMemberNickNameIn(List<String> values) {
addCriterion("member_nick_name in", values, "memberNickName");
return (Criteria) this;
}
public Criteria andMemberNickNameNotIn(List<String> values) {
addCriterion("member_nick_name not in", values, "memberNickName");
return (Criteria) this;
}
public Criteria andMemberNickNameBetween(String value1, String value2) {
addCriterion("member_nick_name between", value1, value2, "memberNickName");
return (Criteria) this;
}
public Criteria andMemberNickNameNotBetween(String value1, String value2) {
addCriterion("member_nick_name not between", value1, value2, "memberNickName");
return (Criteria) this;
}
public Criteria andTopicIdIsNull() {
addCriterion("topic_id is null");
return (Criteria) this;
}
public Criteria andTopicIdIsNotNull() {
addCriterion("topic_id is not null");
return (Criteria) this;
}
public Criteria andTopicIdEqualTo(Long value) {
addCriterion("topic_id =", value, "topicId");
return (Criteria) this;
}
public Criteria andTopicIdNotEqualTo(Long value) {
addCriterion("topic_id <>", value, "topicId");
return (Criteria) this;
}
public Criteria andTopicIdGreaterThan(Long value) {
addCriterion("topic_id >", value, "topicId");
return (Criteria) this;
}
public Criteria andTopicIdGreaterThanOrEqualTo(Long value) {
addCriterion("topic_id >=", value, "topicId");
return (Criteria) this;
}
// 添加条件topic_id < value
public Criteria andTopicIdLessThan(Long value) {
addCriterion("topic_id <", value, "topicId");
return (Criteria) this;
}
// 添加条件topic_id <= value
public Criteria andTopicIdLessThanOrEqualTo(Long value) {
addCriterion("topic_id <=", value, "topicId");
return (Criteria) this;
}
// 添加条件topic_id IN (values)
public Criteria andTopicIdIn(List<Long> values) {
addCriterion("topic_id in", values, "topicId");
return (Criteria) this;
}
// 添加条件topic_id NOT IN (values)
public Criteria andTopicIdNotIn(List<Long> values) {
addCriterion("topic_id not in", values, "topicId");
return (Criteria) this;
}
// 添加条件topic_id BETWEEN value1 AND value2
public Criteria andTopicIdBetween(Long value1, Long value2) {
addCriterion("topic_id between", value1, value2, "topicId");
return (Criteria) this;
}
// 添加条件topic_id NOT BETWEEN value1 AND value2
public Criteria andTopicIdNotBetween(Long value1, Long value2) {
addCriterion("topic_id not between", value1, value2, "topicId");
return (Criteria) this;
}
// 添加条件member_icon IS NULL
public Criteria andMemberIconIsNull() {
addCriterion("member_icon is null");
return (Criteria) this;
}
// 添加条件member_icon IS NOT NULL
public Criteria andMemberIconIsNotNull() {
addCriterion("member_icon is not null");
return (Criteria) this;
}
// 添加条件member_icon = value
public Criteria andMemberIconEqualTo(String value) {
addCriterion("member_icon =", value, "memberIcon");
return (Criteria) this;
}
// 添加条件member_icon <> value
public Criteria andMemberIconNotEqualTo(String value) {
addCriterion("member_icon <>", value, "memberIcon");
return (Criteria) this;
}
// 添加条件member_icon > value
public Criteria andMemberIconGreaterThan(String value) {
addCriterion("member_icon >", value, "memberIcon");
return (Criteria) this;
}
// 添加条件member_icon >= value
public Criteria andMemberIconGreaterThanOrEqualTo(String value) {
addCriterion("member_icon >=", value, "memberIcon");
return (Criteria) this;
}
// 添加条件member_icon < value
public Criteria andMemberIconLessThan(String value) {
addCriterion("member_icon <", value, "memberIcon");
return (Criteria) this;
}
// 添加条件member_icon <= value
public Criteria andMemberIconLessThanOrEqualTo(String value) {
addCriterion("member_icon <=", value, "memberIcon");
return (Criteria) this;
}
// 添加条件member_icon LIKE value
public Criteria andMemberIconLike(String value) {
addCriterion("member_icon like", value, "memberIcon");
return (Criteria) this;
}
// 添加条件member_icon NOT LIKE value
public Criteria andMemberIconNotLike(String value) {
addCriterion("member_icon not like", value, "memberIcon");
return (Criteria) this;
}
// 添加条件member_icon IN (values)
public Criteria andMemberIconIn(List<String> values) {
addCriterion("member_icon in", values, "memberIcon");
return (Criteria) this;
}
// 添加条件member_icon NOT IN (values)
public Criteria andMemberIconNotIn(List<String> values) {
addCriterion("member_icon not in", values, "memberIcon");
return (Criteria) this;
}
// 添加条件member_icon BETWEEN value1 AND value2
public Criteria andMemberIconBetween(String value1, String value2) {
addCriterion("member_icon between", value1, value2, "memberIcon");
return (Criteria) this;
}
// 添加条件member_icon NOT BETWEEN value1 AND value2
public Criteria andMemberIconNotBetween(String value1, String value2) {
addCriterion("member_icon not between", value1, value2, "memberIcon");
return (Criteria) this;
}
// 添加条件content IS NULL
public Criteria andContentIsNull() {
addCriterion("content is null");
return (Criteria) this;
}
// 添加条件content IS NOT NULL
public Criteria andContentIsNotNull() {
addCriterion("content is not null");
return (Criteria) this;
}
// 添加条件content = value
public Criteria andContentEqualTo(String value) {
addCriterion("content =", value, "content");
return (Criteria) this;
}
// 添加条件content <> value
public Criteria andContentNotEqualTo(String value) {
addCriterion("content <>", value, "content");
return (Criteria) this;
}
// 添加条件content > value
public Criteria andContentGreaterThan(String value) {
addCriterion("content >", value, "content");
return (Criteria) this;
}
// 添加条件content >= value
public Criteria andContentGreaterThanOrEqualTo(String value) {
addCriterion("content >=", value, "content");
return (Criteria) this;
}
// 添加条件content < value
public Criteria andContentLessThan(String value) {
addCriterion("content <", value, "content");
return (Criteria) this;
}
// 添加条件content <= value
public Criteria andContentLessThanOrEqualTo(String value) {
addCriterion("content <=", value, "content");
return (Criteria) this;
}
// 添加条件content LIKE value
public Criteria andContentLike(String value) {
addCriterion("content like", value, "content");
return (Criteria) this;
}
// 添加条件content NOT LIKE value
public Criteria andContentNotLike(String value) {
addCriterion("content not like", value, "content");
return (Criteria) this;
}
// 添加条件content IN (values)
public Criteria andContentIn(List<String> values) {
addCriterion("content in", values, "content");
return (Criteria) this;
}
// 添加条件content NOT IN (values)
public Criteria andContentNotIn(List<String> values) {
addCriterion("content not in", values, "content");
return (Criteria) this;
}
// 添加条件content BETWEEN value1 AND value2
public Criteria andContentBetween(String value1, String value2) {
addCriterion("content between", value1, value2, "content");
return (Criteria) this;
}
// 添加条件content NOT BETWEEN value1 AND value2
public Criteria andContentNotBetween(String value1, String value2) {
addCriterion("content not between", value1, value2, "content");
return (Criteria) this;
}
// 添加条件create_time IS NULL
public Criteria andCreateTimeIsNull() {
addCriterion("create_time is null");
return (Criteria) this;
}
// 添加条件create_time IS NOT NULL
public Criteria andCreateTimeIsNotNull() {
addCriterion("create_time is not null");
return (Criteria) this;
}
// 添加条件create_time = value
public Criteria andCreateTimeEqualTo(Date value) {
addCriterion("create_time =", value, "createTime");
return (Criteria) this;
}
// 检查创建时间是否不等于指定值
public Criteria andCreateTimeNotEqualTo(Date value) {
addCriterion("create_time <>", value, "createTime");
return (Criteria) this;
}
// 检查创建时间是否大于指定值
public Criteria andCreateTimeGreaterThan(Date value) {
addCriterion("create_time >", value, "createTime");
return (Criteria) this;
}
// 检查创建时间是否大于或等于指定值
public Criteria andCreateTimeGreaterThanOrEqualTo(Date value) {
addCriterion("create_time >=", value, "createTime");
return (Criteria) this;
}
// 检查创建时间是否小于指定值
public Criteria andCreateTimeLessThan(Date value) {
addCriterion("create_time <", value, "createTime");
return (Criteria) this;
}
// 检查创建时间是否小于或等于指定值
public Criteria andCreateTimeLessThanOrEqualTo(Date value) {
addCriterion("create_time <=", value, "createTime");
return (Criteria) this;
}
// 检查创建时间是否在指定的日期列表中
public Criteria andCreateTimeIn(List<Date> values) {
addCriterion("create_time in", values, "createTime");
return (Criteria) this;
}
// 检查创建时间是否不在指定的日期列表中
public Criteria andCreateTimeNotIn(List<Date> values) {
addCriterion("create_time not in", values, "createTime");
return (Criteria) this;
}
// 检查创建时间是否在指定的日期范围内
public Criteria andCreateTimeBetween(Date value1, Date value2) {
addCriterion("create_time between", value1, value2, "createTime");
return (Criteria) this;
}
// 检查创建时间是否不在指定的日期范围内
public Criteria andCreateTimeNotBetween(Date value1, Date value2) {
addCriterion("create_time not between", value1, value2, "createTime");
return (Criteria) this;
}
// 检查显示状态是否为空
public Criteria andShowStatusIsNull() {
addCriterion("show_status is null");
return (Criteria) this;
}
// 检查显示状态是否不为空
public Criteria andShowStatusIsNotNull() {
addCriterion("show_status is not null");
return (Criteria) this;
}
// 检查显示状态是否等于指定值
public Criteria andShowStatusEqualTo(Integer value) {
addCriterion("show_status =", value, "showStatus");
return (Criteria) this;
}
// 检查显示状态是否不等于指定值
public Criteria andShowStatusNotEqualTo(Integer value) {
addCriterion("show_status <>", value, "showStatus");
return (Criteria) this;
}
// 检查显示状态是否大于指定值
public Criteria andShowStatusGreaterThan(Integer value) {
addCriterion("show_status >", value, "showStatus");
return (Criteria) this;
}
// 检查显示状态是否大于或等于指定值
public Criteria andShowStatusGreaterThanOrEqualTo(Integer value) {
addCriterion("show_status >=", value, "showStatus");
return (Criteria) this;
}
// 检查显示状态是否小于指定值
public Criteria andShowStatusLessThan(Integer value) {
addCriterion("show_status <", value, "showStatus");
return (Criteria) this;
}
// 检查显示状态是否小于或等于指定值
public Criteria andShowStatusLessThanOrEqualTo(Integer value) {
addCriterion("show_status <=", value, "showStatus");
return (Criteria) this;
}
// 检查显示状态是否在指定的整数列表中
public Criteria andShowStatusIn(List<Integer> values) {
addCriterion("show_status in", values, "showStatus");
return (Criteria) this;
}
// 检查显示状态是否不在指定的整数列表中
public Criteria andShowStatusNotIn(List<Integer> values) {
addCriterion("show_status not in", values, "showStatus");
return (Criteria) this;
}
// 检查显示状态是否在指定的整数范围内
public Criteria andShowStatusBetween(Integer value1, Integer value2) {
addCriterion("show_status between", value1, value2, "showStatus");
return (Criteria) this;
}
// 检查显示状态是否不在指定的整数范围内
public Criteria andShowStatusNotBetween(Integer value1, Integer value2) {
addCriterion("show_status not between", value1, value2, "showStatus");
return (Criteria) this;
}
}
public static class Criteria extends GeneratedCriteria {
// 构造函数初始化Criteria对象
protected Criteria() {
super();
}
}
public static class Criterion {
private String condition; // 条件表达式
private Object value; // 条件值
private Object secondValue; // 第二个条件值用于between查询
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; // 如果值为列表则设置listValue为true
} else {
this.singleValue = true; // 否则设置为单一值
}
}
// 构造函数,包含条件表达式和值,不包含类型处理器
protected Criterion(String condition, Object value) {
this(condition, value, null);
}
// 构造函数包含条件表达式、两个值和可选的类型处理器用于between查询
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; // 设置为区间值
}
// 构造函数包含条件表达式、两个值不包含类型处理器用于between查询
protected Criterion(String condition, Object value, Object secondValue) {
this(condition, value, secondValue, null);
}
}
}

Some files were not shown because too many files have changed in this diff Show More

Loading…
Cancel
Save