org.redkale.source.DataSource Maven / Gradle / Ivy
/*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
package org.redkale.source;
import java.io.Serializable;
import java.util.*;
import java.util.concurrent.CompletableFuture;
import java.util.stream.Stream;
import org.redkale.util.*;
/**
*
* DataSource 为数据库或内存数据库的数据源，提供类似JPA、Hibernate的接口与功能。
* 返回类型为CompletableFuture的接口为异步接口
*
*
* 详情见: https://redkale.org
*
* @author zhangjx
*/
@SuppressWarnings("unchecked")
public interface DataSource {
/**
* 获取数据源类型
*
* @return String
*/
public String getType();
//----------------------insertAsync-----------------------------
/**
* 新增记录， 多对象必须是同一个Entity类且必须在同一张表中
*
* @param 泛型
* @param values Entity对象
*
* @return 影响的记录条数
*/
public int insert(final T... values);
/**
* 新增记录， 多对象必须是同一个Entity类且必须在同一张表中
*
* @param 泛型
* @param values Entity对象
*
* @return CompletableFuture
*/
public CompletableFuture insertAsync(final T... values);
//-------------------------deleteAsync--------------------------
/**
* 删除指定主键值的记录， 多对象必须是同一个Entity类且必须在同一张表中
* 等价SQL: DELETE FROM {table} WHERE {primary} IN {values.id}
*
* @param 泛型
* @param values Entity对象
*
* @return 影响的记录条数
*/
public int delete(final T... values);
/**
* 删除指定主键值的记录， 多对象必须是同一个Entity类且必须在同一张表中
* 等价SQL: DELETE FROM {table} WHERE {primary} IN {values.id}
*
* @param 泛型
* @param values Entity对象
*
* @return 影响的记录条数CompletableFuture
*/
public CompletableFuture deleteAsync(final T... values);
/**
* 删除指定主键值的记录,多主键值必须在同一张表中
* 等价SQL: DELETE FROM {table} WHERE {primary} IN {ids}
*
* @param Entity泛型
* @param clazz Entity类
* @param ids 主键值
*
* @return 影响的记录条数
*/
public int delete(final Class clazz, final Serializable... ids);
/**
* 删除指定主键值的记录,多主键值必须在同一张表中
* 等价SQL: DELETE FROM {table} WHERE {primary} IN {ids}
*
* @param Entity泛型
* @param clazz Entity类
* @param ids 主键值
*
* @return 影响的记录条数CompletableFuture
*/
public CompletableFuture deleteAsync(final Class clazz, final Serializable... ids);
/**
* 删除符合过滤条件的记录
* 等价SQL: DELETE FROM {table} WHERE {filter node}
*
* @param Entity泛型
* @param clazz Entity类
* @param node 过滤条件
*
* @return 影响的记录条数
*/
public int delete(final Class clazz, final FilterNode node);
/**
* 删除符合过滤条件的记录
* 等价SQL: DELETE FROM {table} WHERE {filter node}
*
* @param Entity泛型
* @param clazz Entity类
* @param node 过滤条件
*
* @return 影响的记录条数CompletableFuture
*/
public CompletableFuture deleteAsync(final Class clazz, final FilterNode node);
/**
* 删除符合过滤条件且指定最大影响条数的记录
* Flipper中offset字段将被忽略
* 等价SQL: DELETE FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
*
* @param Entity泛型
* @param clazz Entity类
* @param flipper 翻页对象
* @param node 过滤条件
*
* @return 影响的记录条数
*/
public int delete(final Class clazz, final Flipper flipper, final FilterNode node);
/**
* 删除符合过滤条件且指定最大影响条数的记录
* Flipper中offset字段将被忽略
* 等价SQL: DELETE FROM {table} WHERE {filter node} ORDER BY {flipper.sort} LIMIT {flipper.limit}
*
* @param Entity泛型
* @param clazz Entity类
* @param flipper 翻页对象
* @param node 过滤条件
*
* @return 影响的记录条数CompletableFuture
*/
public CompletableFuture deleteAsync(final Class clazz, final Flipper flipper, final FilterNode node);
//------------------------updateAsync---------------------------
/**
* 更新记录， 多对象必须是同一个Entity类且必须在同一张表中
* 等价SQL:
* UPDATE {table} SET column1 = value1, column2 = value2, ··· WHERE {primary} = {id1}
* UPDATE {table} SET column1 = value1, column2 = value2, ··· WHERE {primary} = {id2}
* ···
*
* @param 泛型
* @param values Entity对象
*
* @return 影响的记录条数
*/
public int update(final T... values);
/**
* 更新记录， 多对象必须是同一个Entity类且必须在同一张表中
* 等价SQL:
* UPDATE {table} SET column1 = value1, column2 = value2, ··· WHERE {primary} = {id1}
* UPDATE {table} SET column1 = value1, column2 = value2, ··· WHERE {primary} = {id2}
* ···
*
* @param 泛型
* @param values Entity对象
*
* @return 影响的记录条数CompletableFuture
*/
public CompletableFuture updateAsync(final T... values);
/**
* 更新单个记录的单个字段
* 注意：即使字段标记为@Column(updatable=false)也会被更新
* 等价SQL: UPDATE {table} SET {column} = {value} WHERE {primary} = {id}
*
* @param Entity泛型
* @param clazz Entity类
* @param id 主键
* @param column 待更新的字段名
* @param value 更新值
*
* @return 影响的记录条数
*/
public int updateColumn(final Class clazz, final Serializable id, final String column, final Serializable value);
/**
* 更新单个记录的单个字段
* 注意：即使字段标记为@Column(updatable=false)也会被更新
* 等价SQL: UPDATE {table} SET {column} = {value} WHERE {primary} = {id}
*
* @param Entity泛型
* @param clazz Entity类
* @param id 主键
* @param column 待更新的字段名
* @param value 更新值
*
* @return 影响的记录条数CompletableFuture
*/
public CompletableFuture updateColumnAsync(final Class clazz, final Serializable id, final String column, final Serializable value);
/**
* 更新符合过滤条件记录的单个字段
* 注意：即使字段标记为@Column(updatable=false)也会被更新
* 等价SQL: UPDATE {table} SET {column} = {value} WHERE {filter node}
*
* @param Entity泛型
* @param clazz Entity类
* @param column 待更新的字段名
* @param value 更新值
* @param node 过滤条件
*
* @return 影响的记录条数
*/
public int updateColumn(final Class clazz, final String column, final Serializable value, final FilterNode node);
/**
* 更新符合过滤条件记录的单个字段
* 注意：即使字段标记为@Column(updatable=false)也会被更新
* 等价SQL: UPDATE {table} SET {column} = {value} WHERE {filter node}
*
* @param Entity泛型
* @param clazz Entity类
* @param column 待更新的字段名
* @param value 更新值
* @param node 过滤条件
*
* @return 影响的记录条数CompletableFuture
*/
public CompletableFuture updateColumnAsync(final Class clazz, final String column, final Serializable value, final FilterNode node);
/**
* 更新指定主键值记录的部分字段
* 字段赋值操作选项见 ColumnExpress
* 等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} += {value2}, {column3} *= {value3}, ··· WHERE {filter node}
*
* @param Entity泛型
* @param clazz Entity类
* @param id 主键
* @param values 更新字段
*
* @return 影响的记录条数
*/
public int updateColumn(final Class clazz, final Serializable id, final ColumnValue... values);
/**
* 更新指定主键值记录的部分字段
* 字段赋值操作选项见 ColumnExpress
* 等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} += {value2}, {column3} *= {value3}, ··· WHERE {filter node}
*
* @param Entity泛型
* @param clazz Entity类
* @param id 主键
* @param values 更新字段
*
* @return 影响的记录条数CompletableFuture
*/
public CompletableFuture updateColumnAsync(final Class clazz, final Serializable id, final ColumnValue... values);
/**
* 更新符合过滤条件记录的部分字段
* 字段赋值操作选项见 ColumnExpress
* 注意：Entity类中标记为@Column(updatable=false)不会被更新
* 等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} += {value2}, {column3} *= {value3}, ··· WHERE {filter node}
*
* @param Entity泛型
* @param clazz Entity类
* @param node 过滤条件
* @param values 更新字段
*
* @return 影响的记录条数
*/
public int updateColumn(final Class clazz, final FilterNode node, final ColumnValue... values);
/**
* 更新符合过滤条件记录的部分字段
* 字段赋值操作选项见 ColumnExpress
* 注意：Entity类中标记为@Column(updatable=false)不会被更新
* 等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} += {value2}, {column3} *= {value3}, ··· WHERE {filter node}
*
* @param Entity泛型
* @param clazz Entity类
* @param node 过滤条件
* @param values 更新字段
*
* @return 影响的记录条数CompletableFuture
*/
public CompletableFuture updateColumnAsync(final Class clazz, final FilterNode node, final ColumnValue... values);
/**
* 更新符合过滤条件的记录的指定字段
* Flipper中offset字段将被忽略
* 注意：Entity类中标记为@Column(updatable=false)不会被更新
* 等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} += {value2}, {column3} *= {value3}, ··· WHERE {filter node} ORDER BY {flipper.sort}
*
* @param Entity泛型
* @param clazz Entity类
* @param node 过滤条件
* @param flipper 翻页对象
* @param values 更新字段
*
* @return 影响的记录条数
*/
public int updateColumn(final Class clazz, final FilterNode node, final Flipper flipper, final ColumnValue... values);
/**
* 更新符合过滤条件的记录的指定字段
* Flipper中offset字段将被忽略
* 注意：Entity类中标记为@Column(updatable=false)不会被更新
* 等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} += {value2}, {column3} *= {value3}, ··· WHERE {filter node} ORDER BY {flipper.sort}
*
* @param Entity泛型
* @param clazz Entity类
* @param node 过滤条件
* @param flipper 翻页对象
* @param values 更新字段
*
* @return 影响的记录条数CompletableFuture
*/
public CompletableFuture updateColumnAsync(final Class clazz, final FilterNode node, final Flipper flipper, final ColumnValue... values);
/**
* 更新单个记录的指定字段
* 注意：Entity类中标记为@Column(updatable=false)不会被更新
* 等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} = {value2}, {column3} = {value3}, ··· WHERE {primary} = {bean.id}
*
* @param Entity泛型
* @param bean 待更新的Entity对象
* @param columns 需更新的字段名
*
* @return 影响的记录条数
*/
public int updateColumn(final T bean, final String... columns);
/**
* 更新单个记录的指定字段
* 注意：Entity类中标记为@Column(updatable=false)不会被更新
* 等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} = {value2}, {column3} = {value3}, ··· WHERE {primary} = {bean.id}
*
* @param Entity泛型
* @param bean 待更新的Entity对象
* @param columns 需更新的字段名
*
* @return 影响的记录条数CompletableFuture
*/
public CompletableFuture updateColumnAsync(final T bean, final String... columns);
/**
* 更新符合过滤条件记录的指定字段
* 注意：Entity类中标记为@Column(updatable=false)不会被更新
* 等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} = {value2}, {column3} = {value3}, ··· WHERE {filter node}
*
* @param Entity泛型
* @param bean 待更新的Entity对象
* @param node 过滤条件
* @param columns 需更新的字段名
*
* @return 影响的记录条数
*/
public int updateColumn(final T bean, final FilterNode node, final String... columns);
/**
* 更新符合过滤条件记录的指定字段
* 注意：Entity类中标记为@Column(updatable=false)不会被更新
* 等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} = {value2}, {column3} = {value3}, ··· WHERE {filter node}
*
* @param Entity泛型
* @param bean 待更新的Entity对象
* @param node 过滤条件
* @param columns 需更新的字段名
*
* @return 影响的记录条数CompletableFuture
*/
public CompletableFuture updateColumnAsync(final T bean, final FilterNode node, final String... columns);
/**
* 更新单个记录的指定字段
* 注意：Entity类中标记为@Column(updatable=false)不会被更新
* 等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} = {value2}, {column3} = {value3}, ··· WHERE {primary} = {bean.id}
*
* @param Entity泛型
* @param bean 待更新的Entity对象
* @param selects 指定字段
*
* @return 影响的记录条数
*/
public int updateColumn(final T bean, final SelectColumn selects);
/**
* 更新单个记录的指定字段
* 注意：Entity类中标记为@Column(updatable=false)不会被更新
* 等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} = {value2}, {column3} = {value3}, ··· WHERE {primary} = {bean.id}
*
* @param Entity泛型
* @param bean 待更新的Entity对象
* @param selects 指定字段
*
* @return 影响的记录条数CompletableFuture
*/
public CompletableFuture updateColumnAsync(final T bean, final SelectColumn selects);
/**
* 更新符合过滤条件记录的指定字段
* 注意：Entity类中标记为@Column(updatable=false)不会被更新
* 等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} = {value2}, {column3} = {value3}, ··· WHERE {filter node}
*
* @param Entity泛型
* @param bean 待更新的Entity对象
* @param node 过滤条件
* @param selects 指定字段
*
* @return 影响的记录条数
*/
public int updateColumn(final T bean, final FilterNode node, final SelectColumn selects);
/**
* 更新符合过滤条件记录的指定字段
* 注意：Entity类中标记为@Column(updatable=false)不会被更新
* 等价SQL: UPDATE {table} SET {column1} = {value1}, {column2} = {value2}, {column3} = {value3}, ··· WHERE {filter node}
*
* @param Entity泛型
* @param bean 待更新的Entity对象
* @param node 过滤条件
* @param selects 指定字段
*
* @return 影响的记录条数CompletableFuture
*/
public CompletableFuture updateColumnAsync(final T bean, final FilterNode node, final SelectColumn selects);
//############################################# 查询接口 #############################################
//-----------------------getXXXXResult-----------------------------
/**
* 获取符合过滤条件记录的聚合结果, 无结果返回null
* 等价SQL: SELECT FUNC{column} FROM {table}
* 如 getNumberResultAsync(Record.class, FilterFunc.COUNT, null) 等价于: SELECT COUNT(*) FROM {table}
*
* @param entityClass Entity类
* @param func 聚合函数
* @param column 指定字段
*
* @return 聚合结果
*/
public Number getNumberResult(final Class entityClass, final FilterFunc func, final String column);
/**
* 获取符合过滤条件记录的聚合结果, 无结果返回null
* 等价SQL: SELECT FUNC{column} FROM {table}
* 如 getNumberResultAsync(Record.class, FilterFunc.COUNT, null) 等价于: SELECT COUNT(*) FROM {table}
*
* @param entityClass Entity类
* @param func 聚合函数
* @param column 指定字段
*
* @return 聚合结果CompletableFuture
*/
public CompletableFuture getNumberResultAsync(final Class entityClass, final FilterFunc func, final String column);
/**
* 获取符合过滤条件记录的聚合结果, 无结果返回null
* 等价SQL: SELECT FUNC{column} FROM {table} WHERE {filter bean}
* 如 getNumberResultAsync(Record.class, FilterFunc.COUNT, null, (FilterBean)null) 等价于: SELECT COUNT(*) FROM {table}
*
* @param entityClass Entity类
* @param func 聚合函数
* @param column 指定字段
* @param bean 过滤条件
*
* @return 聚合结果
*/
public Number getNumberResult(final Class entityClass, final FilterFunc func, final String column, final FilterBean bean);
/**
* 获取符合过滤条件记录的聚合结果, 无结果返回null
* 等价SQL: SELECT FUNC{column} FROM {table} WHERE {filter bean}
* 如 getNumberResultAsync(Record.class, FilterFunc.COUNT, null, (FilterBean)null) 等价于: SELECT COUNT(*) FROM {table}
*
* @param entityClass Entity类
* @param func 聚合函数
* @param column 指定字段
* @param bean 过滤条件
*
* @return 聚合结果CompletableFuture
*/
public CompletableFuture getNumberResultAsync(final Class entityClass, final FilterFunc func, final String column, final FilterBean bean);
/**
* 获取符合过滤条件记录的聚合结果, 无结果返回null
* 等价SQL: SELECT FUNC{column} FROM {table} WHERE {filter node}
* 如 getNumberResultAsync(Record.class, FilterFunc.MAX, "createtime", (FilterNode)null) 等价于: SELECT MAX(createtime) FROM {table}
*
* @param entityClass Entity类
* @param func 聚合函数
* @param column 指定字段
* @param node 过滤条件
*
* @return 聚合结果
*/
public Number getNumberResult(final Class entityClass, final FilterFunc func, final String column, final FilterNode node);
/**
* 获取符合过滤条件记录的聚合结果, 无结果返回null
* 等价SQL: SELECT FUNC{column} FROM {table} WHERE {filter node}
* 如 getNumberResultAsync(Record.class, FilterFunc.MAX, "createtime", (FilterNode)null) 等价于: SELECT MAX(createtime) FROM {table}
*
* @param entityClass Entity类
* @param func 聚合函数
* @param column 指定字段
* @param node 过滤条件
*
* @return 聚合结果
*/
public CompletableFuture getNumberResultAsync(final Class entityClass, final FilterFunc func, final String column, final FilterNode node);
/**
* 获取符合过滤条件记录的聚合结果, 无结果返回默认值
* 等价SQL: SELECT FUNC{column} FROM {table}
* 如 getNumberResultAsync(Record.class, FilterFunc.MAX, "createtime") 等价于: SELECT MAX(createtime) FROM {table}
*
* @param entityClass Entity类
* @param func 聚合函数
* @param defVal 默认值
* @param column 指定字段
*
* @return 聚合结果
*/
public Number getNumberResult(final Class entityClass, final FilterFunc func, final Number defVal, final String column);
/**
* 获取符合过滤条件记录的聚合结果, 无结果返回默认值
* 等价SQL: SELECT FUNC{column} FROM {table}
* 如 getNumberResultAsync(Record.class, FilterFunc.MAX, "createtime") 等价于: SELECT MAX(createtime) FROM {table}
*
* @param entityClass Entity类
* @param func 聚合函数
* @param defVal 默认值
* @param column 指定字段
*
* @return 聚合结果CompletableFuture
*/
public CompletableFuture getNumberResultAsync(final Class entityClass, final FilterFunc func, final Number defVal, final String column);
/**
* 获取符合过滤条件记录的聚合结果, 无结果返回默认值
* 等价SQL: SELECT FUNC{column} FROM {table} WHERE {filter bean}
* 如 getNumberResultAsync(Record.class, FilterFunc.MAX, "createtime", (FilterNode)null) 等价于: SELECT MAX(createtime) FROM {table}
*
* @param entityClass Entity类
* @param func 聚合函数
* @param defVal 默认值
* @param column 指定字段
* @param bean 过滤条件
*
* @return 聚合结果
*/
public Number getNumberResult(final Class entityClass, final FilterFunc func, final Number defVal, final String column, final FilterBean bean);
/**
* 获取符合过滤条件记录的聚合结果, 无结果返回默认值
* 等价SQL: SELECT FUNC{column} FROM {table} WHERE {filter bean}
* 如 getNumberResultAsync(Record.class, FilterFunc.MAX, "createtime", (FilterNode)null) 等价于: SELECT MAX(createtime) FROM {table}
*
* @param entityClass Entity类
* @param func 聚合函数
* @param defVal 默认值
* @param column 指定字段
* @param bean 过滤条件
*
* @return 聚合结果CompletableFuture
*/
public CompletableFuture getNumberResultAsync(final Class entityClass, final FilterFunc func, final Number defVal, final String column, final FilterBean bean);
/**
* 获取符合过滤条件记录的聚合结果, 无结果返回默认值
* 等价SQL: SELECT FUNC{column} FROM {table} WHERE {filter node}
* 如 getNumberResultAsync(Record.class, FilterFunc.MAX, "createtime", (FilterNode)null) 等价于: SELECT MAX(createtime) FROM {table}
*
* @param entityClass Entity类
* @param func 聚合函数
* @param defVal 默认值
* @param column 指定字段
* @param node 过滤条件
*
* @return 聚合结果
*/
public Number getNumberResult(final Class entityClass, final FilterFunc func, final Number defVal, final String column, final FilterNode node);
/**
* 获取符合过滤条件记录的聚合结果, 无结果返回默认值
* 等价SQL: SELECT FUNC{column} FROM {table} WHERE {filter node}
* 如 getNumberResultAsync(Record.class, FilterFunc.MAX, "createtime", (FilterNode)null) 等价于: SELECT MAX(createtime) FROM {table}
*
* @param entityClass Entity类
* @param func 聚合函数
* @param defVal 默认值
* @param column 指定字段
* @param node 过滤条件
*
* @return 聚合结果CompletableFuture
*/
public CompletableFuture getNumberResultAsync(final Class entityClass, final FilterFunc func, final Number defVal, final String column, final FilterNode node);
/**
* 获取符合过滤条件记录的聚合结果Map
* 等价SQL: SELECT FUNC1{column1}, FUNC2{column2}, ··· FROM {table}
* 如 getNumberMapAsync(Record.class, new FilterFuncColumn(FilterFunc.MAX, "createtime")) 等价于: SELECT MAX(createtime) FROM {table}
*
* @param Number
* @param entityClass Entity类
* @param columns 聚合字段
*
* @return 聚合结果Map
*/
public Map getNumberMap(final Class entityClass, final FilterFuncColumn... columns);
/**
* 获取符合过滤条件记录的聚合结果Map
* 等价SQL: SELECT FUNC1{column1}, FUNC2{column2}, ··· FROM {table}
* 如 getNumberMapAsync(Record.class, new FilterFuncColumn(FilterFunc.MAX, "createtime")) 等价于: SELECT MAX(createtime) FROM {table}
*
* @param Number
* @param entityClass Entity类
* @param columns 聚合字段
*
* @return 聚合结果Map CompletableFuture
*/
public CompletableFuture> getNumberMapAsync(final Class entityClass, final FilterFuncColumn... columns);
/**
* 获取符合过滤条件记录的聚合结果Map
* 等价SQL: SELECT FUNC1{column1}, FUNC2{column2}, ··· FROM {table} WHERE {filter bean}
* 如 getNumberMapAsync(Record.class, (FilterBean)null, new FilterFuncColumn(FilterFunc.MAX, "createtime")) 等价于: SELECT MAX(createtime) FROM {table}
*
* @param Number
* @param entityClass Entity类
* @param bean 过滤条件
* @param columns 聚合字段
*
* @return 聚合结果Map
*/
public Map getNumberMap(final Class entityClass, final FilterBean bean, final FilterFuncColumn... columns);
/**
* 获取符合过滤条件记录的聚合结果Map
* 等价SQL: SELECT FUNC1{column1}, FUNC2{column2}, ··· FROM {table} WHERE {filter bean}
* 如 getNumberMapAsync(Record.class, (FilterBean)null, new FilterFuncColumn(FilterFunc.MAX, "createtime")) 等价于: SELECT MAX(createtime) FROM {table}
*
* @param Number
* @param entityClass Entity类
* @param bean 过滤条件
* @param columns 聚合字段
*
* @return 聚合结果Map CompletableFuture
*/
public CompletableFuture> getNumberMapAsync(final Class entityClass, final FilterBean bean, final FilterFuncColumn... columns);
/**
* 获取符合过滤条件记录的聚合结果Map
* 等价SQL: SELECT FUNC1{column1}, FUNC2{column2}, ··· FROM {table} WHERE {filter node}
* 如 getNumberMapAsync(Record.class, (FilterNode)null, new FilterFuncColumn(FilterFunc.MAX, "createtime")) 等价于: SELECT MAX(createtime) FROM {table}
*
* @param Number
* @param entityClass Entity类
* @param node 过滤条件
* @param columns 聚合字段
*
* @return 聚合结果Map
*/
public Map getNumberMap(final Class entityClass, final FilterNode node, final FilterFuncColumn... columns);
/**
* 获取符合过滤条件记录的聚合结果Map
* 等价SQL: SELECT FUNC1{column1}, FUNC2{column2}, ··· FROM {table} WHERE {filter node}
* 如 getNumberMapAsync(Record.class, (FilterNode)null, new FilterFuncColumn(FilterFunc.MAX, "createtime")) 等价于: SELECT MAX(createtime) FROM {table}
*
* @param Number
* @param entityClass Entity类
* @param node 过滤条件
* @param columns 聚合字段
*
* @return 聚合结果Map
*/
public CompletableFuture> getNumberMapAsync(final Class entityClass, final FilterNode node, final FilterFuncColumn... columns);
/**
* 查询符合过滤条件记录的GROUP BY聚合结果Map
* 等价SQL: SELECT keyColumn, FUNC{funcColumn} FROM {table} GROUP BY {keyColumn}
* 如 queryColumnMapAsync(Record.class, "name", FilterFunc.MAX, "createtime") 等价于: SELECT name, MAX(createtime) FROM record GROUP BY name
*
* @param Entity泛型
* @param Key字段的数据类型
* @param Number
* @param entityClass Entity类
* @param keyColumn Key字段
* @param func 聚合函数
* @param funcColumn 聚合字段
*
* @return 聚合结果Map
*/
public Map queryColumnMap(final Class entityClass, final String keyColumn, final FilterFunc func, final String funcColumn);
/**
* 查询符合过滤条件记录的GROUP BY聚合结果Map
* 等价SQL: SELECT keyColumn, FUNC{funcColumn} FROM {table} GROUP BY {keyColumn}
* 如 queryColumnMapAsync(Record.class, "name", FilterFunc.MAX, "createtime") 等价于: SELECT name, MAX(createtime) FROM record GROUP BY name
*
* @param Entity泛型
* @param Key字段的数据类型
* @param Number
* @param entityClass Entity类
* @param keyColumn Key字段
* @param func 聚合函数
* @param funcColumn 聚合字段
*
* @return 聚合结果Map CompletableFuture
*/
public CompletableFuture> queryColumnMapAsync(final Class entityClass, final String keyColumn, final FilterFunc func, final String funcColumn);
/**
* 查询符合过滤条件记录的GROUP BY聚合结果Map
* 等价SQL: SELECT keyColumn, FUNC{funcColumn} FROM {table} WHERE {filter bean} GROUP BY {keyColumn}
* 如 queryColumnMapAsync(Record.class, "name", FilterFunc.MAX, "createtime", (FilterBean)null) 等价于: SELECT name, MAX(createtime) FROM record GROUP BY name
*
* @param Entity泛型
* @param Key字段的数据类型
* @param Number
* @param entityClass Entity类
* @param keyColumn Key字段
* @param func 聚合函数
* @param funcColumn 聚合字段
* @param bean 过滤条件
*
* @return 聚合结果Map
*/
public Map queryColumnMap(final Class entityClass, final String keyColumn, final FilterFunc func, final String funcColumn, final FilterBean bean);
/**
* 查询符合过滤条件记录的GROUP BY聚合结果Map
* 等价SQL: SELECT keyColumn, FUNC{funcColumn} FROM {table} WHERE {filter bean} GROUP BY {keyColumn}
* 如 queryColumnMapAsync(Record.class, "name", FilterFunc.MAX, "createtime", (FilterBean)null) 等价于: SELECT name, MAX(createtime) FROM record GROUP BY name
*
* @param Entity泛型
* @param Key字段的数据类型
* @param Number
* @param entityClass Entity类
* @param keyColumn Key字段
* @param func 聚合函数
* @param funcColumn 聚合字段
* @param bean 过滤条件
*
* @return 聚合结果Map CompletableFuture
*/
public CompletableFuture> queryColumnMapAsync(final Class entityClass, final String keyColumn, final FilterFunc func, final String funcColumn, final FilterBean bean);
/**
* 查询符合过滤条件记录的GROUP BY聚合结果Map
* 等价SQL: SELECT keyColumn, FUNC{funcColumn} FROM {table} WHERE {filter node} GROUP BY {keyColumn}
* 如 queryColumnMapAsync(Record.class, "name", FilterFunc.MAX, "createtime", (FilterNode)null) 等价于: SELECT name, MAX(createtime) FROM record GROUP BY name
*
* @param Entity泛型
* @param Key字段的数据类型
* @param Number
* @param entityClass Entity类
* @param keyColumn Key字段
* @param func 聚合函数
* @param funcColumn 聚合字段
* @param node 过滤条件
*
* @return 聚合结果Map
*/
public Map queryColumnMap(final Class entityClass, final String keyColumn, final FilterFunc func, final String funcColumn, final FilterNode node);
/**
* 查询符合过滤条件记录的GROUP BY聚合结果Map
* 等价SQL: SELECT keyColumn, FUNC{funcColumn} FROM {table} WHERE {filter node} GROUP BY {keyColumn}
* 如 queryColumnMapAsync(Record.class, "name", FilterFunc.MAX, "createtime", (FilterNode)null) 等价于: SELECT name, MAX(createtime) FROM record GROUP BY name
*
* @param Entity泛型
* @param Key字段的数据类型
* @param Number
* @param entityClass Entity类
* @param keyColumn Key字段
* @param func 聚合函数
* @param funcColumn 聚合字段
* @param node 过滤条件
*
* @return 聚合结果Map CompletableFuture
*/
public CompletableFuture> queryColumnMapAsync(final Class entityClass, final String keyColumn, final FilterFunc func, final String funcColumn, final FilterNode node);
//-----------------------findAsync----------------------------
/**
* 获取指定主键值的单个记录, 返回null表示不存在值
* 等价SQL: SELECT * FROM {table} WHERE {primary} = {id}
*
* @param Entity泛型
* @param clazz Entity类
* @param pk 主键值
*
* @return Entity对象
*/
public T find(final Class clazz, final Serializable pk);
/**
* 获取指定主键值的单个记录, 返回null表示不存在值
* 等价SQL: SELECT * FROM {table} WHERE {primary} = {id}
*
* @param Entity泛型
* @param clazz Entity类
* @param pk 主键值
*
* @return Entity对象 CompletableFuture
*/
public CompletableFuture findAsync(final Class clazz, final Serializable pk);
/**
* 获取指定主键值的单个记录, 返回null表示不存在值
* 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {primary} = {id}
*
* @param Entity泛型
* @param clazz Entity类
* @param selects 指定字段
* @param pk 主键值
*
* @return Entity对象
*/
public T find(final Class clazz, final SelectColumn selects, final Serializable pk);
/**
* 获取指定主键值的单个记录, 返回null表示不存在值
* 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {primary} = {id}
*
* @param Entity泛型
* @param clazz Entity类
* @param selects 指定字段
* @param pk 主键值
*
* @return Entity对象CompletableFuture
*/
public CompletableFuture findAsync(final Class clazz, final SelectColumn selects, final Serializable pk);
/**
* 获取符合过滤条件单个记录, 返回null表示不存在值
* 等价SQL: SELECT * FROM {table} WHERE {column} = {key}
*
* @param Entity泛型
* @param clazz Entity类
* @param column 过滤字段名
* @param key 过滤字段值
*
* @return Entity对象
*/
public T find(final Class clazz, final String column, final Serializable key);
/**
* 获取符合过滤条件单个记录, 返回null表示不存在值
* 等价SQL: SELECT * FROM {table} WHERE {column} = {key}
*
* @param Entity泛型
* @param clazz Entity类
* @param column 过滤字段名
* @param key 过滤字段值
*
* @return Entity对象CompletableFuture
*/
public CompletableFuture findAsync(final Class clazz, final String column, final Serializable key);
/**
* 获取符合过滤条件单个记录, 返回null表示不存在值
* 等价SQL: SELECT * FROM {table} WHERE {filter bean}
*
* @param Entity泛型
* @param clazz Entity类
* @param bean 过滤条件
*
* @return Entity对象
*/
public T find(final Class clazz, final FilterBean bean);
/**
* 获取符合过滤条件单个记录, 返回null表示不存在值
* 等价SQL: SELECT * FROM {table} WHERE {filter bean}
*
* @param Entity泛型
* @param clazz Entity类
* @param bean 过滤条件
*
* @return Entity对象CompletableFuture
*/
public CompletableFuture findAsync(final Class clazz, final FilterBean bean);
/**
* 获取符合过滤条件单个记录, 返回null表示不存在值
* 等价SQL: SELECT * FROM {table} WHERE {filter node}
*
* @param Entity泛型
* @param clazz Entity类
* @param node 过滤条件
*
* @return Entity对象
*/
public T find(final Class clazz, final FilterNode node);
/**
* 获取符合过滤条件单个记录, 返回null表示不存在值
* 等价SQL: SELECT * FROM {table} WHERE {filter node}
*
* @param Entity泛型
* @param clazz Entity类
* @param node 过滤条件
*
* @return Entity对象CompletableFuture
*/
public CompletableFuture findAsync(final Class clazz, final FilterNode node);
/**
* 获取符合过滤条件单个记录, 返回null表示不存在值
* 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter bean}
*
* @param Entity泛型
* @param clazz Entity类
* @param selects 指定字段
* @param bean 过滤条件
*
* @return Entity对象
*/
public T find(final Class clazz, final SelectColumn selects, final FilterBean bean);
/**
* 获取符合过滤条件单个记录, 返回null表示不存在值
* 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter bean}
*
* @param Entity泛型
* @param clazz Entity类
* @param selects 指定字段
* @param bean 过滤条件
*
* @return Entity对象 CompletableFuture
*/
public CompletableFuture findAsync(final Class clazz, final SelectColumn selects, final FilterBean bean);
/**
* 获取符合过滤条件单个记录, 返回null表示不存在值
* 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter node}
*
* @param Entity泛型
* @param clazz Entity类
* @param selects 指定字段
* @param node 过滤条件
*
* @return Entity对象
*/
public T find(final Class clazz, final SelectColumn selects, final FilterNode node);
/**
* 获取符合过滤条件单个记录, 返回null表示不存在值
* 等价SQL: SELECT {column1},{column2}, ··· FROM {table} WHERE {filter node}
*
* @param Entity泛型
* @param clazz Entity类
* @param selects 指定字段
* @param node 过滤条件
*
* @return Entity对象 CompletableFuture
*/
public CompletableFuture findAsync(final Class clazz, final SelectColumn selects, final FilterNode node);
/**
* 获取符合过滤条件单个记录的单个字段值, 返回null表示不存在值
* 等价SQL: SELECT {column} FROM {table} WHERE {primary} = {id}
*
* @param Entity泛型
* @param clazz Entity类
* @param column 字段名
* @param pk 主键值
*
* @return Entity对象
*/
public Serializable findColumn(final Class clazz, final String column, final Serializable pk);
/**
* 获取符合过滤条件单个记录的单个字段值, 返回null表示不存在值
* 等价SQL: SELECT {column} FROM {table} WHERE {primary} = {id}
*
* @param Entity泛型
* @param clazz Entity类
* @param column 字段名
* @param pk 主键值
*
* @return Entity对象 CompletableFuture
*/
public CompletableFuture findColumnAsync(final Class clazz, final String column, final Serializable pk);
/**
* 获取符合过滤条件单个记录的单个字段值, 返回null表示不存在值
* 等价SQL: SELECT {column} FROM {table} WHERE {filter bean}
*
* @param Entity泛型
* @param clazz Entity类
* @param column 字段名
* @param bean 过滤条件
*
* @return 字段值
*/
public Serializable findColumn(final Class clazz, final String column, final FilterBean bean);
/**
* 获取符合过滤条件单个记录的单个字段值, 返回null表示不存在值
* 等价SQL: SELECT {column} FROM {table} WHERE {filter bean}
*
* @param Entity泛型
* @param clazz Entity类
* @param column 字段名
* @param bean 过滤条件
*
* @return 字段值 CompletableFuture
*/
public CompletableFuture findColumnAsync(final Class clazz, final String column, final FilterBean bean);
/**
* 获取符合过滤条件单个记录的单个字段值, 返回null表示不存在值
* 等价SQL: SELECT {column} FROM {table} WHERE {filter node}
*
* @param Entity泛型
* @param clazz Entity类
* @param column 字段名
* @param node 过滤条件
*
* @return 字段值
*/
public Serializable findColumn(final Class clazz, final String column, final FilterNode node);
/**
* 获取符合过滤条件单个记录的单个字段值, 返回null表示不存在值
* 等价SQL: SELECT {column} FROM {table} WHERE {filter node}
*
* @param Entity泛型
* @param clazz Entity类
* @param column 字段名
* @param node 过滤条件
*
* @return 字段值 CompletableFuture
*/
public CompletableFuture findColumnAsync(final Class clazz, final String column, final FilterNode node);
/**
* 获取符合过滤条件单个记录的单个字段值, 不存在值则返回默认值
* 等价SQL: SELECT {column} FROM {table} WHERE {primary} = {id}
*
* @param Entity泛型
* @param clazz Entity类
* @param column 字段名
* @param defValue 默认值
* @param pk 主键值
*
* @return 字段值
*/
public Serializable findColumn(final Class clazz, final String column, final Serializable defValue, final Serializable pk);
/**
* 获取符合过滤条件单个记录的单个字段值, 不存在值则返回默认值
* 等价SQL: SELECT {column} FROM {table} WHERE {primary} = {id}
*
* @param Entity泛型
* @param clazz Entity类
* @param column 字段名
* @param defValue 默认值
* @param pk 主键值
*
* @return 字段值 CompletableFuture
*/
public CompletableFuture findColumnAsync(final Class clazz, final String column, final Serializable defValue, final Serializable pk);
/**
* 获取符合过滤条件单个记录的单个字段值, 不存在值则返回默认值
* 等价SQL: SELECT {column} FROM {table} WHERE {filter bean}
*
* @param Entity泛型
* @param clazz Entity类
* @param column 字段名
* @param defValue 默认值
* @param bean 过滤条件
*
* @return 字段值
*/
public Serializable findColumn(final Class clazz, final String column, final Serializable defValue, final FilterBean bean);
/**
* 获取符合过滤条件单个记录的单个字段值, 不存在值则返回默认值
* 等价SQL: SELECT {column} FROM {table} WHERE {filter bean}
*
* @param Entity泛型
* @param clazz Entity类
* @param column 字段名
* @param defValue 默认值
* @param bean 过滤条件
*
* @return 字段值 CompletableFuture
*/
public CompletableFuture findColumnAsync(final Class clazz, final String column, final Serializable defValue, final FilterBean bean);
/**
* 获取符合过滤条件单个记录的单个字段值, 不存在值则返回默认值
* 等价SQL: SELECT {column} FROM {table} WHERE {filter node}
*
* @param Entity泛型
* @param clazz Entity类
* @param column 字段名
* @param defValue 默认值
* @param node 过滤条件
*
* @return 字段值
*/
public Serializable findColumn(final Class clazz, final String column, final Serializable defValue, final FilterNode node);
/**
* 获取符合过滤条件单个记录的单个字段值, 不存在值则返回默认值
* 等价SQL: SELECT {column} FROM {table} WHERE {filter node}
*
* @param Entity泛型
* @param clazz Entity类
* @param column 字段名
* @param defValue 默认值
* @param node 过滤条件
*
* @return 字段值 CompletableFuture
*/
public CompletableFuture findColumnAsync(final Class clazz, final String column, final Serializable defValue, final FilterNode node);
/**
* 判断是否存在主键值的记录
* 等价SQL: SELECT COUNT(*) FROM {table} WHERE {primary} = {id}
*
* @param Entity泛型
* @param clazz Entity类
* @param pk 主键值
*
* @return 是否存在
*/
public boolean exists(final Class clazz, final Serializable pk);
/**
* 判断是否存在主键值的记录
* 等价SQL: SELECT COUNT(*) FROM {table} WHERE {primary} = {id}
*
* @param Entity泛型
* @param clazz Entity类
* @param pk 主键值
*
* @return 是否存在CompletableFuture
*/
public CompletableFuture existsAsync(final Class clazz, final Serializable pk);
/**
* 判断是否存在符合过滤条件的记录