@Table("b_upload_file")
public class UploadFile implements Serializable {
    private static final long serialVersionUID = -1L;

    /**
     * @Id注解用于标记表的主键，目前只支持单主键，请不要在多个属性上设置此注解，会导致程序出错
     *
     * idType: 主键ID策略，目前支持以下7种 AUTO_INCREMENT、INPUT、OBJECT_ID、ASSIGN_ID、UUID、SEQUENCE、CUSTOM
     * value: 则代表的是sequence 序列的 sql 内容，idType=SEQUENCE时，必须设置此内容
     * 
     * 注意！
     * 如果设置为 AUTO_INCREMENT 自增主键 的话，则此字段必须为Long
     * 如果设置为 UUID 的话，则此属性类型必须为String
     * 如果设置为 OBJECT_ID 的话，则此属性类型必须为String
     * 如果设置为 ASSIGN_ID 的话，则此属性类型必须为String或者Long
     * 如果设置为 SEQUENCE 的话，则此属性类型必须为Integer或者Long，且必须设置value属性为查询序列值的SQL
     * 如果设置为 CUSTOM 的话，则需要自己实现 IdGeneratorInterface 接口并注册为bean
     * 
     * 
     * @Column注解用于标记属性和表字段的对应关系
     */
    @Id(idType = IdType.AUTO_INCREMENT)
    @Column(value = "id")
    private Long id;

    /**
     * 文件id
     */
    @Column("file_id")
    private String fileId;

    /**
     * 文件原名称
     */
    @Column("file_name_old")
    private String fileNameOld;

    /**
     * 文件新名称
     */
    @Column("file_name_new")
    private String fileNameNew;

    /**
     * 文件路径
     */
    @Column("file_path")
    private String filePath;

    /**
     * 文件md5
     */
    @Column("file_md5")
    private String fileMd5;

    /**
     * 上传时间
     */
    @Column("created_at")
    private Date createdAt;

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    ...
}

import org.springframework.stereotype.Repository;
import org.tinycloud.jdbc.BaseDao;
import org.tinycloud.entity.UploadFile;

@Repository
public class UploadFileDao extends BaseDao<UploadFile, Long> {
    
    ...
}

import org.springframework.stereotype.Service;
import org.tinycloud.dao.UploadFileDao;

@Service
public class UploadFileService {

    @Autowired
    private UploadFileDao uploadFileDao;
    
    ...
}

@Table("b_upload_file")
public class UploadFile implements Serializable {
 private static final long serialVersionUID = -1L;

 ...
}

 @Table("b_upload_file")
 public class UploadFile implements Serializable {
     private static final long serialVersionUID = -1L;
     
     @Id(idType = IdType.AUTO_INCREMENT)
     @Column(value = "id")
     private Long id;
     ...
 }

 @Table("b_upload_file")
 public class UploadFile implements Serializable {
     private static final long serialVersionUID = -1L;

     @Id(idType = IdType.AUTO_INCREMENT)
     @Column(value = "id")
     private Long id;
     
     @Column("file_id")
     private String fileId;

 }

    List<Integer> ids = new ArrayList<Integer>(){{
        add(1);
        add(2);
        add(3);
    }};

    QueryCriteria<Person> criteria = new QueryCriteria<>();
    criteria.lt("age", 28);
    criteria.eq("created_at", new java.util.Date());
    criteria.in("id", ids);
    criteria.orderBy("age", true);
// 等价于 WHERE age < 28 AND created_at = '2023-08-05 17:31:26' AND id IN (1,2,3) ORDER BY age DESC

    QueryCriteria<Person> criteria = new QueryCriteria<>();
    criteria.select("id", "name");
    criteria.lt("age",28);
// 等价于 SELECT id,name FROM xxxx WHERE age < 28

    List<Long> ids = new ArrayList<Long>(){{
        add(1L);
        add(2L);
        add(3L);
    }};

  LambdaQueryCriteria<UploadFile> criteria = new LambdaQueryCriteria<>();
  criteria.lt(UploadFile::getFileId, "1000");
  criteria.eq(UploadFile::getFileMd5, "b8394b15e02c50b508b3e46cc120f0f5");
  criteria.in(UploadFile::getId, ids);
  criteria.orderBy(UploadFile::getCreatedAt, true);

// 等价于  WHERE file_id < '1000' AND file_md5 = 'b8394b15e02c50b508b3e46cc120f0f5' AND id IN (1,2,3) ORDER BY created_at DESC

  LambdaQueryCriteria<UploadFile> criteria = new LambdaQueryCriteria<>();
  criteria.select(UploadFile::getFileId, UploadFile::getFileMd5);
  criteria.lt(UploadFile::getFileId, "1000");
// 等价于 SELECT file_id,file_md5 FROM b_upload_file WHERE file_id < '1000'

int num = projectInfoDao.update(new UpdateCriteria<TProjectInfo>()
                .set("created_at", new Date())
                .set("updated_by", "admin3")
                .eq("project_name", "批量项目1"));
// 等价于 UPDATE xxxx SET created_at = '2023-08-05 17:31:26', updated_by = 'admin3' WHERE project_name = '批量项目1'

TProjectInfo project1 = new TProjectInfo();
project1.setCreatedAt(new Date());
project1.setUpdatedBy("admin3");
int num = projectInfoDao.update(project1, new UpdateCriteria<TProjectInfo>().eq("project_name", "批量项目1"));
// 等价于 UPDATE xxxx SET created_at = '2023-08-05 17:31:26', updated_by = 'admin3' WHERE project_name = '批量项目1'

int num = projectInfoDao.update(new LambdaUpdateCriteria<TProjectInfo>()
                        .set(TProjectInfo::getEnableAt, new Date())
                        .set(TProjectInfo::getUpdatedBy, "admin2")
                .eq(TProjectInfo::getProjectName, "批量项目1"));
// 等价于 UPDATE xxxx SET enable_at = '2023-08-05 17:31:26', updated_by = 'admin2' WHERE project_name = '批量项目1'

TProjectInfo project1 = new TProjectInfo();
project1.setCreatedAt(new Date());
project1.setUpdatedBy("admin3");
int num = projectInfoDao.update(project1, new LambdaUpdateCriteria<TProjectInfo>().eq(TProjectInfo::getProjectName, "批量项目1"));
// 等价于 UPDATE xxxx SET created_at = '2023-08-05 17:31:26', updated_by = 'admin3' WHERE project_name = '批量项目1'

@Component
public class CustomIdGeneratorInterface implements IdGeneratorInterface {

    @Override
    public Object nextId(Object entity) {
        // 可以将当前传入的class全类名来作为业务键,
        // 或者通过反射获取表名进行业务Id调用生成
        String bizKey = entity.getClass().getName();
        // 自定义ID生成策略，推荐最终返回值使用包装类
        Long id = ....;
        // 返回生成的id值即可.
        return id;
    }
}

@Bean
public IdGeneratorInterface idGenerator(){
        return new IdGeneratorInterface() {
            @Override
            public Object nextId(Object entity) {
                // 可以将当前传入的class全类名来作为业务键,
                // 或者通过反射获取表名进行业务Id调用生成
                String bizKey = entity.getClass().getName();
                // 自定义ID生成策略，推荐最终返回值使用包装类
                Long id = ....;
                // 返回生成的id值即可.
                return id;
            }
        };
}

@Component
public class CustomSnowflakeConfigInterface implements SnowflakeConfigInterface {

    @Override
    public Pair<Long, Long> getDatacenterIdAndWorkerId() {
        Pair<Long, Long> pair = new Pair<Long, Long>();
        
        // 自定义datacenterId和workerId生成逻辑
        Long datacenterId = ....;
        Long workerId = ....;
        
        pair.setLeft(datacenterId);
        pair.setRight(workerId);
        return pair;
    }
}

@Bean
public SnowflakeConfigInterface snowflakeConfigInterface() {
        return new SnowflakeConfigInterface() {
            @Override
            public Pair<Long, Long> getDatacenterIdAndWorkerId() {
                // 自定义datacenterId和workerId生成逻辑
                Long datacenterId = ....;
                Long workerId = ....;
                return Pair.of(datacenterId, workerId); 
            }
        };
}

package org.example.mapper;

import org.example.entity.TProjectInfo;
import org.springframework.stereotype.Repository;
import org.tinycloud.jdbc.BaseDao;

@Repository
public class ProjectInfoDao extends BaseDao<TProjectInfo, Long> {

}

@Autowired
private ProjectDao projectDao;

// 查询所有的项目，返回列表
List<TProjectInfo> projectList = projectDao.select("select * from t_project_info order by created_at desc");

// 自定义返回类型，返回列表
List<ProjectInfoVo> projectList = projectDao.select("select * from t_project_info order by created_at desc", ProjectInfoVo.class);

// 查询所有的项目，返回列表
List<TProjectInfo> projectList = projectDao.select("select * from t_project_info order by created_at desc");

// 查询所以的项目，返回Map列表
List<Map<String, Object>>projectList = projectDao.selectMap("select * from t_project_info order by created_at desc");

// 查询id=1的项目，返回列表
List<TProjectInfo> projectList = projectDao.select("select * from t_project_info where id = ? ", 1);

// 模糊查询项目，返回列表
List<TProjectInfo> projectList = projectDao.select("select * from t_project_info where project_name like CONCAT('%', ?, '%')", "测试项目");

// 查询id=1的项目，返回对象
TProjectInfo project = projectDao.selectOne("select * from t_project_info where id = ? ", 1);

// 查询记录数
Integer count = projectDao.selectOneColumn("select count(*) from t_project_info order by created_at desc", Integer.class));

// 分页查询id>100的记录，第一页，每页10个
Page<TProjectInfo> page = projectDao.paginate("select * from t_project_info order by created_at desc where id > ?",new Page<TProjectInfo>(1,10),100));

// 查询id=3的项目信息列表
TProjectInfo project = new TProjectInfo();
project.setId(3L);
List<TProjectInfo> projectList = projectDao.select(project);

// 查询id=3的项目信息
TProjectInfo project = new TProjectInfo();
project.setId(3L);
Project project = projectDao.selectOne(project);

// 查询id=3的项目信息
TProjectInfo project=projectDao.selectById(3L);

// 查询id=3和id=4的项目信息
List<Long> ids = new ArrayList<Long>();
ids.add(3L);
ids.add(4L);
TProjectInfo project=projectDao.selectByIds(ids)

// 查询id=3的项目信息
LambdaQueryCriteria<TProjectInfo> criteria = new LambdaQueryCriteria<>().eq(Project::getId, 3L);
TProjectInfo project = projectDao.selectOne(criteria);

// 查询id=3的项目信息
QueryCriteria<TProjectInfo> criteria = new QueryCriteria<>().eq("id",3L);
TProjectInfo project = projectDao.selectOne(criteria);

// 分页查询id=3的项目信息，第一页，每页10个
TProjectInfo project = new TProjectInfo();
project.setId(3L);
Page<TProjectInfo> page = projectDao.paginate(project,new Page<TProjectInfo>(1, 10));

// 分页查询id=3的项目信息，第一页，每页10个
QueryCriteria<TProjectInfo> criteria = new QueryCriteria()<>.eq("id", 3L);
Page<TProjectInfo> page = projectDao.paginate(criteria,new Page<TProjectInfo>(1, 10));

// 根据条件构造器构建复杂查询条件
// 等价于 `SELECT id,project_name ,del_flag,created_by,updated_by,created_at AS createdAt,updated_at,remark FROM t_project_info WHERE created_by = 'admin' AND del_flag >= 0 AND id IN (1, 5) OR (remark NOT LIKE '%XXX%') ORDER BY created_at DESC`
List<Long> ids = new ArrayList<>();
ids.add(1L);
ids.add(5L);
LambdaQueryCriteria<TProjectInfo> criteria = new LambdaQueryCriteria<>()
    .eq(TProjectInfo::getCreatedBy, "admin")
    .gte(TProjectInfo::getDelFlag, 0)
    .in(TProjectInfo::getId, ids)
    .or(i -> i.notLike(TProjectInfo::getRemark, "XXX"))
    .orderBy(TProjectInfo::getCreatedAt, true);
List<TProjectInfo> projectList = projectDao.select(criteria);


// 根据条件构造器查询记录数量，等价于 `SELECT COUNT(*) FROM t_project_info WHERE id = 1695713712801116162`
LambdaQueryCriteria<TProjectInfo> criteria = new LambdaQueryCriteria<>().eq(Project::getId,1695713712801116162L);
Long count=projectDao.selectCount(criteria);

// 根据条件构造器查询记录是否存在，等价于 `SELECT COUNT(*) FROM t_project_info WHERE id = 1695713712801116162`，然后再判断结果count是否大于0
LambdaQueryCriteria<TProjectInfo> criteria = new LambdaQueryCriteria<>().eq(Project::getId,1695713712801116162L);
boolean result = projectDao.exists(criteria)

@Autowired
private ProjectDao projectDao;

// 使用sql插入一条数据
int result = projectDao.insert("insert t_into project_info(project_name, del_flag, remark) values (?,?,?)","测试项目",1,"XXXXXXX");

// 使用实体类插入一条数据，默认忽略null
TProjectInfo project = new TProjectInfo();
project.setProjectName("xxxx");
project.setDelFlag(1);
project.setCreatedBy("admin");
project.setRemark("XXXX");
int result=projectDao.insert(project);

// 获取生成的主键id，在主键策略为assignId、uuid或objectId时适用
Long id = project.getId();

// 使用实体类插入一条数据，不忽略null
int result = projectDao.insert(project,false);

// 获取生成的主键id，在主键策略为assignId、uuid或objectId时适用
Long id = project.getId();

// 使用实体类插入一条数据，并返回数据库自增的主键值，默认忽略null
int result = projectDao.insertReturnAutoIncrement(project);

@Autowired
private ProjectDao projectDao;

// 使用sql插入一条数据
int result = baseDao.update(""update project_info set project_name=?where id=?"",new Object[]{"测试项目",1});

// 使用实体类更新一条数据，其中以主键Id值为where条件，默认忽略null，等价于 `update t_project_info set project_name='测试项目',del_flag=1,created_by='admin',remark='XXXX' where id=1`
TProjectInfo project = new TProjectInfo();
project.setId(1);
project.setProjectName("测试项目");
project.setDelFlag(1);
project.setCreatedBy("admin");
project.setRemark("XXXX");
int result = baseDao.updateById(project);

// 使用实体类更新一条数据，不忽略null，等价于 `update t_project_info set project_name='测试项目',del_flag=1,created_by='admin',remark='XXXX',updated_by=NULL,created_at=NULL,updated_at=NULL where id=1`
int result = baseDao.updateById(project, false);

// 根据条件构造器（Lambda）作为条件更新一条数据，默认忽略null，等价于 `update t_project_info set project_name='测试项目' where id=1`
TProjectInfo project2 = new TProjectInfo();
project2.setProjectName("测试项目");
LambdaUpdateCriteria<TProjectInfo> criteria = new LambdaUpdateCriteria<>().eq(TProjectInfo::getId(), 1L)
int result=baseDao.update(project2, criteria);

// 根据实体类内容和条件构造器作为条件更新一条数据，默认忽略null，等价于 `update t_project_info set project_name='测试项目' where id=1`
UpdateCriteria<TProjectInfo> criteria = new UpdateCriteria<>().eq("id", 1L)
int result = update.update(project2, criteria);

// 根据实体类内容和条件构造器作为条件更新一条数据，不忽略null，等价于 `update t_project_info set project_name='测试项目',del_flag=NULL,created_by=NULL,remark=NULL,updated_by=NULL,created_at=NULL,updated_at=NULL where id=1`
UpdateCriteria<TProjectInfo> criteria = new UpdateCriteria<>().eq("id", 1L)
int result = update.update(project2, false, criteria);

// 只根据条件构造器作为条件更新一条数据，等价于 `update t_project_info set project_name='测试项目' where id=1`
UpdateCriteria<TProjectInfo> criteria = new UpdateCriteria<>().set("project_name", "测试项目").eq("id",1L);
int result = baseDao.update(criteria);

// 只根据条件构造器（Lambda）作为条件更新一条数据，等价于 `update t_project_info set project_name='测试项目' where id=1`
LambdaUpdateCriteria<TProjectInfo> criteria = new LambdaUpdateCriteria<>().set(TProjectInfo::getProjectName, "测试项目").eq("id",1L);
int result = baseDao.update(criteria);

@Autowired
private ProjectDao projectDao;

// 使用sql删除一条数据
int result = projectDao.delete(""delete from t_project_info where id=?"", new Object[]{1});

// 根据实体类非null内容作为where条件删除一条数据，等价于 `delete from t_project_info where id = 1`
TProjectInfo project = new TProjectInfo();
project.setId(1);
int result = baseDao.delete(project);

// 根据主键id删除一条数据，等价于 `delete from t_project_info where id = 1`
int result = baseDao.deleteById(1L);

// 根据主键id列表删除多条数据，等价于 `delete from t_project_info where id in (1, 5)`
List<Long> ids = new ArrayList<Long>();
ids.add(1L);
ids.add(5L);
int result = baseDao.deleteByIds(ids);

// 根据主键id数组删除多条数据，等价于 `delete from t_project_info where id in (1, 5)`
List<Long> ids = new ArrayList<Long>();
int result = baseDao.deleteByIds(1L, 5L);

// 根据条件构造器（Lambda）作为查询条件删除一条数据，等价于 `delete from t_project_info where id = 1`
LambdaUpdateCriteria<TProjectInfo> criteria = new LambdaUpdateCriteria<>().eq(Project::getId(), 1L)
int result = baseDao.delete(criteria);

// 根据条件构造器作为查询条件删除一条数据，等价于 `delete from t_project_info where id = 1`
UpdateCriteria<TProjectInfo> criteria = new UpdateCriteria<>().eq("id", 1L)
int result = baseDao.delete(criteria);