TSQL

LowLevelSelectSqlDAO

包含的方法如下，详情见LowLevelSelectSqlDAO类：

readManyListMap

 /**
     * sql批量查询
     *
     * @param selectSql 查询TSQL，比如：select a.`f1`, b.`f2` from test_Model1 a left join test_Model2 b on a.`f3`= b.`f4` where b.`f5` > 5 limit 10
     * @return 满足查询条件的Map<String, Object>列表
     */
    List<Map<String, Object>> readManyListMap(@NonNull String selectSql);

    /**
     * sql批量查询
     *
     * @param preparedSql 查询TSQL，比如：select a.`f1`, b.`f2` from test_Model1 a left join test_Model2 b on a.`f3`= b.`f4` where b.`f5` > :f5Value limit :pageSize
     * @param paramsMap   sql变量绑定值Map<key:变量名, value:Object>，变量名以:开头，比如：:f3Value、:pageSize
     * @return 满足查询条件的Map<String, Object>列表
     */
    List<Map<String, Object>> readManyListMap(@NonNull String preparedSql, @NonNull Map<String, Object> paramsMap);

readManyListObject

 /**
     * sql批量查询
     *
     * @param selectSql   查询TSQL，比如：select a.`f1`, b.`f2` from test_Model1 a left join test_Model2 b on a.`f3`= b.`f4` where b.`f5` > 5 limit 10
     * @param objectClass 目标对象类型
     * @param <T>         目标对象类型
     * @return 满足查询条件的目标对象类型列表
     */
    <T> List<T> readManyListObject(@NonNull String selectSql, Class<T> objectClass);

    /**
     * sql批量查询
     *
     * @param preparedSql 查询TSQL，比如：select a.`f1`, b.`f2` from test_Model1 a left join test_Model2 b on a.`f3`= b.`f4` where b.`f5` > :f5Value limit :pageSize
     * @param paramsMap   sql变量绑定值Map<key:变量名, value:Object>，变量名以:开头，比如：:f3Value、:pageSize
     * @param objectClass 目标对象类型
     * @param <T>         目标对象类型
     * @return 满足查询条件的目标对象类型列表
     */
    <T> List<T> readManyListObject(@NonNull String preparedSql, @NonNull Map<String, Object> paramsMap, Class<T> objectClass);

使用示例：

@Component
@NoArgsConstructor
public class StudentLowLevelSqlDAO {

    @Autowired
    private TrantorLowLevelSqlDAO trantorLowLevelSqlDAO;

    private final static String querySQL = "select student.id,student.stuNo,student.age, student.name, studentCard.studentCardId from " +
            "example_sql_Student student left join example_sql_StudentCard studentCard on student.studentCard = studentCard.id";
    private final static String countSQL = "select count(1) as count from " +
            "example_sql_Student student left join example_sql_StudentCard studentCard on student.studentCard = studentCard.id";

    public Paging<Student> pageWithTotal(MultiDataParams multiDataParams) {
        Map<String, Object> params = new HashMap<>(16);
        // count
        String countSqlStr = buildSqlAndParam(countSQL, multiDataParams, params);
        List<Map<String, Object>> countMaps = trantorLowLevelSqlDAO.readManyListMap(countSqlStr, params);
        long total = NumberUtils.toLong(String.valueOf(countMaps.get(0).get("count")));
        // query
        String querySqlWithoutLimit = buildSqlAndParam(querySQL, multiDataParams, params);
        String querySqlStr = buildPageAndOrder(querySqlWithoutLimit, multiDataParams, params);
        List<Map<String, Object>> dataList = trantorLowLevelSqlDAO.readManyListMap(querySqlStr, params);
        // deal data
        List<Student> studentList = new ArrayList<>();
        for (Map<String, Object> map : dataList) {
            JSONObject json = JSON.parseObject(JSON.toJSONString(map));
            Student student = JSON.toJavaObject(json, Student.class);
            studentList.add(student);
        }
        // return data
        Paging<Student> paging = new Paging<>();
        paging.setTotal(total);
        paging.setData(studentList);
        return paging;
    }

    /**
     * 还支持 ><= 和 is null&is not null
     * <p>
     * builder.append(" and ( student.createdAt > :getAtStart and b.createdAt < :getAtEnd ) ");
     * params.put(":getAtStart", createAt);
     * params.put(":getAtEnd", updateAt;
     * <p>
     * builder.append(" and student.id is null");
     * builder.append(" and student.name is null and student.id is not null ");
     * builder.append(" and student.id is not null ");
     *
     * @param sql
     * @param multiDataParams
     * @param params
     * @return
     */
    private String buildSqlAndParam(String sql, MultiDataParams multiDataParams, Map<String, Object> params) {
        StringBuilder builder = new StringBuilder(sql);
        String name = multiDataParams.getQueryValues().getOneValue(Student.name_field);
        String stuNo = multiDataParams.getQueryValues().getOneValue(Student.stuNo_field);

        if (StringUtils.isNotBlank(name)) {
            builder.append(" and student.name = :name ");
            params.put(":name", name);
        }
        if (StringUtils.isNotBlank(stuNo)) {
            builder.append(" and student.stuNo = :stuNo ");
            params.put(":stuNo", stuNo);
        }
        return builder.toString();
    }

    private String buildPageAndOrder(String sql, MultiDataParams multiDataParams, Map<String, Object> params) {
        StringBuilder builder = new StringBuilder(sql);
        Integer pageNo = multiDataParams.getPaging().getNo();
        Integer pageSize = multiDataParams.getPaging().getSize();
        PageInfo pageInfo = new PageInfo(pageNo, pageSize);
        builder.append(" order by student.createdAt desc ");
        builder.append(" limit :offset,:limit");
        params.put(":offset", pageInfo.getOffset());
        params.put(":limit", pageInfo.getLimit());
        return builder.toString();
    }
}

TrantorSqlDAO

类似于TrantorDAO，TrantorSqlDAO也是通过继承的方式使用。

@Repository
public class StudentSqlDao extends TrantorSqlDAO<Student, Long> {

}

TrantorSqlDAO结构如下：

public abstract class TrantorSqlDAO<MODEL extends RootModel<ID>, ID extends Serializable>
    implements
    ApplicationContextAware,
    CreateOrUpdateSqlDAO<MODEL, ID>,
    CreateSqlDAO<MODEL, ID>,
    ReadSqlDAO<MODEL, ID>,
    UpdateSqlDAO<MODEL, ID>,
    DeleteSqlDAO<MODEL, ID> {
    ...//接口实现
}

InsertSqlDAO

createOne

/**
 * 单个创建模型
 * 等价TSQL：insert into Model values(model.*)
 *
 * @param model 模型实例
 * @return 新建模型实例ID
 */
ID createOne(@NonNull Model model);

createMany

 /**
     * 批量创建模型列表
     * 等价TSQL：insert into Model values(model1.*),(model2.*),(model3.*)...
     *
     * @param models 模型实例列表
     * @return 模型实例ID列表
     */
    List<ID> createMany(@NonNull Collection<Model> models);

UpdateSqlDAO

updateOne

/**
 * 单个修改：根据id
 * 等价TSQL：update Model set model.* where id=model.id
 *
 * @param model                    模型实例
 * @param isExcludeNullValueFields 是否排除值为null的字段（当取值为false时，sql中会出现set field = null；否则，不会）
 * @return true-模型实例更新成功
 */
Boolean updateOne(@NonNull Model model, @NonNull Boolean isExcludeNullValueFields);

updateMany

/**
 * 批量修改
 * 等价TSQL：update Model set model1.* where id=model1.id; update Model set model2.* where id=model2.id; ...
 *
 * @param models                   模型实例列表
 * @param isExcludeNullValueFields 是否排除值为null的字段（当取值为false时，sql中会出现set field = null；否则，不会）
 * @return 实际更新的模型实例个数
 */
Long updateMany(@NonNull Collection<Model> models, @NonNull Boolean isExcludeNullValueFields);

/**
 * sql自定义更新
 * 相同字段：等价TSQL：update Model m set m.amount=m.amount-100 where m.amount>=100
 * 不同字段：等价TSQL：update Model m set m.amount=m.price where m.amount>=m.price
 * 乐观锁：等价TSQL：update Model m set m.version=m.version+1 where m.id=1 and m.version=2
 * 条件lt/lte/gt/gte/in/eq：等价TSQL：update Model m set m.field1='value1' where m.id < 10
 *
 * @param updateSql 更新TSQL
 * @return 实际更新的模型实例个数
 */
Long updateMany(@NonNull String updateSql);

updateOptimisticLock

 /**
     * 更新乐观锁
     * 等价TSQL：update Model m set m.lockFieldName=m.lockFieldName+1 where m.id=:id and m.lockFieldName=:currentValue
     *
     * @param id           模型实例ID
     * @param lockField    乐观锁字段名
     * @param currentValue 乐观锁字段当前值
     * @return 是否更新成功
     */
    Boolean updateOptimisticLock(@NonNull ID id, @NonNull String lockField, @NonNull Long currentValue);

InsertOrUpdateSqlDAO

createOrUpdateOne

/**
 * 单个创建或修改模型
 * 等价TSQL：if model.id=null then insert into Model values(model.*) else update Model set model.* where id=model.id
 *
 * @param model 模型实例
 * @return 模型实例ID
 */
ID createOrUpdateOne(@NonNull Model model);

createOrUpdateMany

    /**
     * 批量创建或修改模型列表
     * 等价TSQL：if model.id=null then insert into Model values(models.*) else update Model set models.* where id=model.id
     *
     * @param models 模型实例列表
     * @return 模型实例ID列表
     */
    List<ID> createOrUpdateMany(@NonNull Collection<Model> models);

DeleteSqlDAO

deleteOne

/**
 * 单个删除
 * 等价TSQL：delete from Model where id=id
 *
 * @param id 模型实例ID
 * @return 是否删除成功
 */
Boolean deleteOne(@NonNull ID id);

deleteMany

/**
 * 批量删除
 * 等价TSQL：delete from Model where id in (ids)
 *
 * @param ids 模型实例ID列表
 * @return 删除成功数量
 */
Long deleteMany(@NonNull Collection<ID> ids);

deleteCondition

/**
 * 条件删除
 * 等价TSQL：delete from Model where condition
 * 多种条件：lt/lte/gt/gte/in/eq/and/or/not等
 *
 * @param condition 删除条件，为空时表示删除所有模型实例，等价于deleteAll()
 * @return 删除成功数量
 */
Long deleteCondition(Condition condition);

deleteAll

/**
 * 删除所有
 * 等价TSQL：delete from Model
 *
 * @return 删除成功数量
 */
Long deleteAll();

SelectSqlDAO

readMany

/**
 * sql批量查询
 *
 * @param selectDSL 查询条件jooq DSL，比如：
 *                  <pre>
 *                   Condition condition = SqlDSL.field(MyModel.createdAt_field).eq(field(MyModel.updatedAt_field))
 *                       .and(field(MyModel.f1_field).eq(100)
 *                           .or(field(MyModel.f2_field).gt(50))
 *                           .or(field(MyModel.f3_field).ge(20))
 *                       );
 *
 *                   Query select = SelectSqlDSL.selectModelAndFields(mySqlDAO.getModelKey(), MyModel.f4_field, MyModel.f5_field)
 *                       .where(condition)
 *                       .orderBy(field(MyModel.f4_field).desc(), field(MyModel.f5_field).asc())
 *                       .limit(10)
 *                       .offset((20 - 1) * 10);
 *                  </pre>
 * @return 满足查询条件的模型实例列表
 */
List<Model> readMany(@NonNull Query selectDSL);

/**
 * sql批量查询
 *
 * @param selectSql 查询TSQL，比如：select `f1`, `f2` from test_TestCompany where `id` in (1, 2, 3) and `f3` > 5
 * @return 满足查询条件的模型实例列表
 */
List<Model> readMany(@NonNull String selectSql);

/**
 * sql批量查询
 *
 * @param preparedSql 查询TSQL，比如：select `f1`, `f2` from test_TestCompany where `id` in (:idList) and `f3` > :f3Value
 * @param paramsMap   sql变量绑定值Map<key:变量名, value:Object>，变量名以:开头，比如：:idList、:f3Value
 * @return 满足查询条件的模型实例列表
 */
List<Model> readMany(@NonNull String preparedSql, @NonNull Map<String, Object> paramsMap);
/**
 * 根据ID列表批量查询
 * 等价TSQL：select returnFields from Model where id in (ids)
 *
 * @param ids          模型实例ID列表
 * @param returnFields 返回字段列表，为空时表示查询所有字段，比如：MyModel.f1_field、MyModel.f2_field
 * @return 满足查询条件的模型实例列表
 */
List<Model> readMany(@NonNull Collection<ID> ids, String... returnFields);

/**
 * 自定义条件批量查询
 * <p>
 * e.g.
 * lt/lte/gt/gte/in/eq/like等条件：select m.field1, m.filed2.field1 from Model m where m.id < :param2Name and name like CONCAT('%', ?, '%')
 * 相同字段：select m.field1, m.filed2.field1 from Model m where m.amount>=100
 * 不同字段：select m.field1, m.filed2.field1 from Model m where m.amount>=m.price
 *
 * @param condition    自定义查询条件，为空时表示查询所有模型实例，比如：Condition condition = SqlDSL.field(MyModel.f1_field).eq(10);
 * @param returnFields 返回字段列表，为空时表示查询所有字段，比如：MyModel.f1_field、MyModel.f2_field
 * @return 满足查询条件的模型实例列表
 */
List<Model> readMany(Condition condition, String... returnFields);

/**
 * 自定义条件批量查询
 * <p>
 * e.g.
 * lt/lte/gt/gte/in/eq/like等条件：select m.field1, m.filed2.field1 from Model m where m.id < :param2Name and name like CONCAT('%', ?, '%')
 * 相同字段：select m.field1, m.filed2.field1 from Model m where m.amount>=100
 * 不同字段：select m.field1, m.filed2.field1 from Model m where m.amount>=m.price
 *
 * @param condition    自定义查询条件，为空时表示查询所有模型实例，比如：Condition condition = SqlDSL.field(MyModel.f1_field).eq(10);
 * @param orderFields  排序字段列表，为空时表示不排序，比如：SqlDSL.field(MyModel.f1_field).desc() 表示按f1字段降序
 * @param returnFields 返回字段列表，为空时表示查询所有字段，比如：MyModel.f1_field、MyModel.f2_field
 * @return 满足查询条件的模型实例列表
 */
List<Model> readMany(Condition condition, Collection<SortField<?>> orderFields, String... returnFields);

readAll

/**
 * 全量查询（警告：当记录数很大时不要使用，请使用分页查询）
 * 等价TSQL：select `f1`, `f2` from Model
 *
 * @param returnFields 返回字段列表，为空时表示查询所有字段，比如：MyModel.f1_field、MyModel.f2_field
 * @return 满足查询条件的模型实例列表
 */
List<Model> readAll(String... returnFields);

page

    /**
     * 分页查询
     * 等价TSQL：select `f1`, `f2` from Model where condition order by `f3` asc, `f4` desc limit pageSize offset (pageNo-1)*pageSize
     *
     * @param pageNo       页码（从1开始）
     * @param pageSize     每页大小
     * @param returnFields 返回字段列表，为空时表示查询所有字段，比如：MyModel.f1_field、MyModel.f2_field
     * @param condition    自定义查询条件，为空时表示查询所有模型实例，比如：Condition condition = SqlDSL.field(MyModel.f1_field).eq(10);
     * @param orderFields  排序字段列表，为空时表示不指定排序，比如：SqlDSL.field(MyModel.f1_field).desc() 表示按f1字段降序
     * @return 满足查询条件的模型实例列表
     */
    List<Model> page(int pageNo, int pageSize, Collection<String> returnFields, Condition condition, SortField<?>... orderFields);

pageWithTotal

/**
 * 分页查询（返回总数）
 * 等价TSQL：
 * - 1 select count(*) from Model where condition
 * - 2 select `f1`, `f2` from Model where condition order by `f3` asc, `f4` desc limit pageSize offset (pageNo-1)*pageSize
 *
 * @param pageNo       页码（从1开始）
 * @param pageSize     每页大小
 * @param returnFields 返回字段列表，为空时表示查询所有字段，比如：MyModel.f1_field、MyModel.f2_field
 * @param condition    自定义查询条件，为空时表示查询所有模型实例，比如：Condition condition = SqlDSL.field(MyModel.f1_field).eq(10);
 * @param orderFields  排序字段列表，为空时表示不指定排序，比如：SqlDSL.field(MyModel.f1_field).desc() 表示按f1字段降序
 * @return 满足查询条件的模型实例列表和总数
 */
Paging<Model> pageWithTotal(int pageNo, int pageSize, Collection<String> returnFields, Condition condition, SortField<?>... orderFields);

readManyDistinct

/**
 * 查询字段剔重
 * 等价TSQL：select distinct returnFields from Model where condition
 *
 * @param condition    自定义查询条件，为空时表示查询所有模型实例，比如：Condition condition = SqlDSL.field(MyModel.f1_field).eq(10);
 * @param returnFields 返回字段列表，为空时表示查询所有字段，比如：MyModel.f1_field、MyModel.f2_field
 * @return 满足查询条件的模型实例列表
 */
List<Model> readManyDistinct(Condition condition, String... returnFields);

exists

/**
 * 是否存在满足查询条件的数据
 *
 * @param condition 查询条件，比如：Condition condition = SqlDSL.field(MyModel.f1_field).eq(10);
 * @return true-存在
 */
Boolean exists(@NonNull Condition condition);

countAll

/**
 * 不分组统计查询：数量
 * 等价TSQL：select count(*) from Model
 *
 * @return 所有模型实例数量
 */
Long countAll();

count

/**
 * 不分组统计查询：数量
 * 等价TSQL：select count(*) from Model where condition
 *
 * @param condition 自定义查询条件，为空时表示查询所有模型实例，比如：Condition condition = SqlDSL.field(MyModel.f1_field).eq(10);
 * @return 满足查询条件的模型实例数量
 */
Long count(Condition condition);

countByConditionSql

/**
 * 不分组统计查询：数量
 * 等价TSQL：select count(*) from Model where condition
 *
 * @param conditionSql 自定义查询条件，比如：`f1`=1 and `f2`>5
 * @return 满足查询条件的模型实例数量
 */
Long countByConditionSql(@NonNull String conditionSql);

countBySql

/**
 * 不分组统计查询：数量
 * 等价TSQL：select count(*) from Model where condition
 *
 * @param countSql 自定义查询sql，比如：select count(*) from Model where `f1`=1 and `f2`>5
 * @return 满足查询条件的模型实例数量
 */
Long countBySql(@NonNull String countSql);

 /**
  * 不分组统计查询：数量
  * 等价TSQL：select count(*) from Model where condition
  *
  * @param preparedSql 自定义查询sql，比如：select count(*)  from test_TestCompany where `f1` = :f2Value and `f2` > :f2Value
  * @param paramsMap   sql变量绑定值Map<key:变量名, value:Object>，变量名以:开头，比如：:f1Value、:f2Value
  * @return 满足查询条件的模型实例数量
  */
 Long countBySql(@NonNull String preparedSql, @NonNull Map<String, Object> paramsMap);

min

/**
 * 不分组统计查询：最小值
 * 等价TSQL：select min(minField) from Model where condition
 *
 * @param minField  最小值模型字段名，比如：MyModel.f1_field、MyModel.f2_field
 * @param condition 自定义查询条件，为空时表示查询所有模型实例，比如：Condition condition = SqlDSL.field(MyModel.f1_field).eq(10);
 * @return 模型字段最小值
 */
Object min(@NonNull String minField, Condition condition);

max

/**
 * 不分组统计查询：最大值
 * 等价TSQL：select max(maxField) from Model where condition
 *
 * @param maxField  最大值模型字段名，比如：MyModel.f1_field、MyModel.f2_field
 * @param condition 自定义查询条件，为空时表示查询所有模型实例，比如：Condition condition = SqlDSL.field(MyModel.f1_field).eq(10);
 * @return 模型字段最大值
 */
Object max(@NonNull String maxField, Condition condition);

avg

/**
 * 不分组统计查询：平均值
 * 等价TSQL：select avg(avgField) from Model where condition
 *
 * @param avgField  平均值模型字段名，比如：MyModel.f1_field、MyModel.f2_field
 * @param condition 自定义查询条件，为空时表示查询所有模型实例，比如：Condition condition = SqlDSL.field(MyModel.f1_field).eq(10);
 * @return 模型字段平均值
 */
Object avg(@NonNull String avgField, Condition condition);

sum

/**
 * 不分组统计查询：求和
 * 等价TSQL：select sum(sumField) from Model where condition
 *
 * @param sumField  求和模型字段名，比如：MyModel.f1_field、MyModel.f2_field
 * @param condition 自定义查询条件，为空时表示查询所有模型实例，比如：Condition condition = SqlDSL.field(MyModel.f1_field).eq(10);
 * @return 模型字段求和
 */
Object sum(@NonNull String sumField, Condition condition);

stat

/**
 * 不分组统计查询：统计值，包括数量、最小值、最大值、平均值、求和等
 * 等价TSQL：select count(*),min(statField),max(statField),avg(statField),sum(statField) from Model where condition
 *
 * @param statField 统计值模型字段名，比如：MyModel.f1_field、MyModel.f2_field
 * @param condition 自定义查询条件，为空时表示查询所有模型实例，比如：Condition condition = SqlDSL.field(MyModel.f1_field).eq(10);
 * @return 模型字段最大值
 */
Map<String, Object> stat(@NonNull String statField, Condition condition);

countByGroup

/**
 * 分组统计查询：数量
 * 等价TSQL：select groupField,count(*) from Mode where condition group by groupField
 *
 * @param condition   自定义查询条件，为空时表示查询所有模型实例，比如：Condition condition = SqlDSL.field(MyModel.f1_field).eq(10);
 * @param groupFields 分组字段列表，比如：MyModel.f1_field、MyModel.f2_field
 * @return 分组统计结果列表<key ： 分组字段或统计类型 ， value ： 分组字段值或统计值>
 */
List<Map<String, Object>> countByGroup(Condition condition, @NonNull String... groupFields);

minByGroup

/**
 * 分组统计查询：最小值
 * 等价TSQL：select groupField,min(minField) from Model where condition group by groupField
 *
 * @param condition   自定义查询条件，为空时表示查询所有模型实例，比如：Condition condition = SqlDSL.field(MyModel.f1_field).eq(10);
 * @param minField    最小值字段，比如：MyModel.f1_field、MyModel.f2_field
 * @param groupFields 分组字段列表，比如：MyModel.f1_field、MyModel.f2_field
 * @return 分组统计结果列表<key ： 分组字段或统计类型 ， value ： 分组字段值或统计值>
 */
List<Map<String, Object>> minByGroup(Condition condition, @NonNull String minField, @NonNull String... groupFields);

maxByGroup

/**
 * 分组统计查询：最大值
 * 等价TSQL：select groupField,max(maxField) from Model where condition group by groupField
 *
 * @param condition   自定义查询条件，为空时表示查询所有模型实例，比如：Condition condition = SqlDSL.field(MyModel.f1_field).eq(10);
 * @param maxField    最大值字段，比如：MyModel.f1_field、MyModel.f2_field
 * @param groupFields 分组字段列表，比如：MyModel.f1_field、MyModel.f2_field
 * @return 分组统计结果列表<key ： 分组字段或统计类型 ， value ： 分组字段值或统计值>
 */
List<Map<String, Object>> maxByGroup(Condition condition, @NonNull String maxField, @NonNull String... groupFields);

avgByGroup

/**
 * 分组统计查询：平均值
 * 等价TSQL：select groupField,avg(avgField) from Model where condition group by groupField
 *
 * @param condition   自定义查询条件，为空时表示查询所有模型实例，比如：Condition condition = SqlDSL.field(MyModel.f1_field).eq(10);
 * @param avgField    平均值字段，比如：MyModel.f1_field、MyModel.f2_field
 * @param groupFields 分组字段列表，比如：MyModel.f1_field、MyModel.f2_field
 * @return 分组统计结果列表<key ： 分组字段或统计类型 ， value ： 分组字段值或统计值>
 */
List<Map<String, Object>> avgByGroup(Condition condition, @NonNull String avgField, @NonNull String... groupFields);

sumByGroup

/**
 * 分组统计查询：求和
 * 等价TSQL：select groupField,sum(sumField) from Model where condition group by groupField
 *
 * @param condition   自定义查询条件，为空时表示查询所有模型实例，比如：Condition condition = SqlDSL.field(MyModel.f1_field).eq(10);
 * @param sumField    求和字段，比如：MyModel.f1_field、MyModel.f2_field
 * @param groupFields 分组字段列表，比如：MyModel.f1_field、MyModel.f2_field
 * @return 分组统计结果列表<key ： 分组字段或统计类型 ， value ： 分组字段值或统计值>
 */
List<Map<String, Object>> sumByGroup(Condition condition, @NonNull String sumField, @NonNull String... groupFields);

statByGroup

/**
 * 分组统计查询：统计值，包括数量、最小值、最大值、平均值、求和等
 * 等价TSQL：select `groupField1`,`groupField2`,`groupField3`,count(*),min(`statField`),max(`statField`),avg(`statField`),sum(`statField`) from `Model` where `id` > 1 group by `groupField1`,`groupField2`,`groupField3`
 *
 * @param condition   自定义查询条件，为空时表示查询所有模型实例，比如：Condition condition = SqlDSL.field(MyModel.f1_field).eq(10);
 * @param statField   统计字段，比如：MyModel.f1_field、MyModel.f2_field
 * @param groupFields 分组字段列表，比如：MyModel.f1_field、MyModel.f2_field
 * @return 分组统计结果列表<key ： 分组字段或统计类型 ， value ： 分组字段值或统计值>
 */
List<Map<String, Object>> statByGroup(Condition condition, @NonNull String statField, @NonNull String... groupFields);

使用示例：

SingleDataAction使用

@Component
public class StudentSingleDataAction implements SingleDataAction<Student> {
    @Autowired
    private StudentSqlDao studentSqlDao;

    @Override
    public SingleDataResult<Student> load(SingleDataParams singleDataParams) {
        Integer id = singleDataParams.getQueryValues().getOneValue("id");
        Student student = studentSqlDao.readOne(id.longValue());

        SingleDataResult<Student> result = new SingleDataResult<>();
        result.setData(student);
        return result;
    }
}

MultiDataAction使用

@Component
public class StudentMultiDataAction2 implements MultiDataAction<Student> {

    @Autowired
    private StudentSqlDao studentSqlDao;

    @Override
    public MultiDataResult<Student> load(MultiDataParams multiDataParams) {
        Long count = studentSqlDao.countAll();
        DataSourceInput.PagingParam paging = multiDataParams.getPaging();
        List<Student> studentList = studentSqlDao.page(paging.getNo(), paging.getSize(), Collections.emptyList(), null);

        MultiDataResult<Student> multiDataResult = new MultiDataResult<>();
        multiDataResult.setData(studentList);
        multiDataResult.setCount(count);
        return multiDataResult;
    }
}

ServerAction使用

@Slf4j
@Component
public class StudentServerAction {

    @Autowired
    private StudentSqlDao studentSqlDao;

    @TAction(modelClass = Student.class)
    public void create(@TParam Student student) {
        Long id = studentSqlDao.createOne(student);
        log.debug("created id:{}", id);
    }

    @TAction(modelClass = Student.class)
    public void update(@TParam Student student) {
        Boolean updated = studentSqlDao.updateOne(student, true);
        log.debug("model:{}, updated:{}", student, updated);
    }

    @TAction(modelClass = Student.class)
    @DSTransaction
    public void updateByIds(@TCollectionParam(Long.class) List<Long> id) {
        /**
         *  还可以表示字段的加减乘除
         *  String sql = "update %s set %s=%s-100, updatedBy=%s where id in (%s)";
         *  String sql = "update %s set %s=%s*100, updatedBy=%s where id in (%s)";
         *  String sql = "update %s set %s=%s/100, updatedBy=%s where id in (%s)";
         */
        String sql = "update %s set %s=%s+100, updatedBy=%s where id in (%s)";
        sql = String.format(sql, studentSqlDao.getModelKey(),
                Student.age_field,
                Student.age_field,
                TContext.getCurrentUserIdSafe().get(),
                id.stream().map(String::valueOf).collect(Collectors.joining(","))
        );
        Long updated = studentSqlDao.updateMany(sql);
        log.debug("model:{}, updated:{}", id, updated);
    }

    @TAction(modelClass = Student.class)
    @DSTransaction
    public void updateByIdsAndField(@TCollectionParam(Long.class) List<Long> id, @TParam("name") String name) {
        List<Student> models = id.stream()
                .map(oneId -> {
                    Student model = new Student();
                    model.setId(oneId);
                    model.setName(name);
                    return model;
                })
                .collect(Collectors.toList());
        Long updated = studentSqlDao.updateMany(models, true);
        log.debug("ids:{}, updated:{}", id, updated);
    }

    @TAction(modelClass = Student.class)
    @DSTransaction
    public void deleteById(@TParam("id") Long id) {
        Boolean deleted = studentSqlDao.deleteOne(id);
        log.debug("id:{}, deleted:{}", id, deleted);
    }

}