lxy/redkale
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

DataSource.queryMap重载了FilterBean、FilterNode参数等系列方法

Browse Source
This commit is contained in:
Redkale
2017-10-30 09:49:34 +08:00
parent 78f1bd90f4
commit 500545fc93
2 changed files with 202 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

94
src/org/redkale/source/DataJdbcSource.java
View File

@@ -1915,6 +1915,48 @@ public class DataJdbcSource extends AbstractService implements DataSource, DataC
return CompletableFuture.supplyAsync(() -> queryMap(clazz, null, keyStream), getExecutor()); return CompletableFuture.supplyAsync(() -> queryMap(clazz, null, keyStream), getExecutor());
} }
/**
* 查询符合过滤条件记录的Map集合, 主键值为key <br>
* 等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit} <br>
*
* @param <K> 主键泛型
* @param <T> Entity泛型
* @param clazz Entity类
* @param bean FilterBean
*
* @return Entity的集合
*/
@Override
public <K extends Serializable, T> Map<K, T> queryMap(final Class<T> clazz, final FilterBean bean) {
return queryMap(clazz, null, bean);
}
@Override
public <K extends Serializable, T> CompletableFuture<Map<K, T>> queryMapAsync(final Class<T> clazz, final FilterBean bean) {
return CompletableFuture.supplyAsync(() -> queryMap(clazz, null, bean), getExecutor());
}
/**
* 查询符合过滤条件记录的Map集合, 主键值为key <br>
* 等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit} <br>
*
* @param <K> 主键泛型
* @param <T> Entity泛型
* @param clazz Entity类
* @param node FilterNode
*
* @return Entity的集合
*/
@Override
public <K extends Serializable, T> Map<K, T> queryMap(final Class<T> clazz, final FilterNode node) {
return queryMap(clazz, null, node);
}
@Override
public <K extends Serializable, T> CompletableFuture<Map<K, T>> queryMapAsync(final Class<T> clazz, final FilterNode node) {
return CompletableFuture.supplyAsync(() -> queryMap(clazz, null, node), getExecutor());
}
/** /**
* 查询符合过滤条件记录的Map集合, 主键值为key <br> * 查询符合过滤条件记录的Map集合, 主键值为key <br>
* 等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit} <br> * 等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit} <br>
@@ -1948,6 +1990,58 @@ public class DataJdbcSource extends AbstractService implements DataSource, DataC
return CompletableFuture.supplyAsync(() -> queryMap(clazz, selects, keyStream), getExecutor()); return CompletableFuture.supplyAsync(() -> queryMap(clazz, selects, keyStream), getExecutor());
} }
/**
* 查询符合过滤条件记录的Map集合, 主键值为key <br>
* 等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit} <br>
*
* @param <K> 主键泛型
* @param <T> Entity泛型
* @param clazz Entity类
* @param selects 指定字段
* @param bean FilterBean
*
* @return Entity的集合
*/
@Override
public <K extends Serializable, T> Map<K, T> queryMap(final Class<T> clazz, final SelectColumn selects, final FilterBean bean) {
return queryMap(clazz, selects, FilterNodeBean.createFilterNode(bean));
}
@Override
public <K extends Serializable, T> CompletableFuture<Map<K, T>> queryMapAsync(final Class<T> clazz, final SelectColumn selects, final FilterBean bean) {
return CompletableFuture.supplyAsync(() -> queryMap(clazz, selects, FilterNodeBean.createFilterNode(bean)), getExecutor());
}
/**
* 查询符合过滤条件记录的Map集合, 主键值为key <br>
* 等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit} <br>
*
* @param <K> 主键泛型
* @param <T> Entity泛型
* @param clazz Entity类
* @param selects 指定字段
* @param node FilterNode
*
* @return Entity的集合
*/
@Override
public <K extends Serializable, T> Map<K, T> queryMap(final Class<T> clazz, final SelectColumn selects, final FilterNode node) {
final EntityInfo<T> info = loadEntityInfo(clazz);
final Attribute<T, Serializable> primary = info.primary;
List<T> rs = queryList(clazz, selects, node);
Map<K, T> map = new LinkedHashMap<>();
if (rs.isEmpty()) return new LinkedHashMap<>();
for (T item : rs) {
map.put((K) primary.get(item), item);
}
return map;
}
@Override
public <K extends Serializable, T> CompletableFuture<Map<K, T>> queryMapAsync(final Class<T> clazz, final SelectColumn selects, final FilterNode node) {
return CompletableFuture.supplyAsync(() -> queryMap(clazz, selects, node), getExecutor());
}
/** /**
* 根据指定字段值查询对象集合 * 根据指定字段值查询对象集合
* *

108
src/org/redkale/source/DataSource.java
View File

@@ -1519,6 +1519,58 @@ public interface DataSource {
*/ */
public <K extends Serializable, T> CompletableFuture<Map<K, T>> queryMapAsync(final Class<T> clazz, final Stream<K> keyStream); public <K extends Serializable, T> CompletableFuture<Map<K, T>> queryMapAsync(final Class<T> clazz, final Stream<K> keyStream);
/**
* 查询符合过滤条件记录的Map集合, 主键值为key <br>
* 等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit} <br>
*
* @param <K> 主键泛型
* @param <T> Entity泛型
* @param clazz Entity类
* @param bean FilterBean
*
* @return Entity的集合
*/
public <K extends Serializable, T> Map<K, T> queryMap(final Class<T> clazz, final FilterBean bean);
/**
* 查询符合过滤条件记录的List集合 <br>
* 等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit} <br>
*
* @param <K> 主键泛型
* @param <T> Entity泛型
* @param clazz Entity类
* @param bean FilterBean
*
* @return Entity的集合CompletableFuture
*/
public <K extends Serializable, T> CompletableFuture<Map<K, T>> queryMapAsync(final Class<T> clazz, final FilterBean bean);
/**
* 查询符合过滤条件记录的Map集合, 主键值为key <br>
* 等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit} <br>
*
* @param <K> 主键泛型
* @param <T> Entity泛型
* @param clazz Entity类
* @param node FilterNode
*
* @return Entity的集合
*/
public <K extends Serializable, T> Map<K, T> queryMap(final Class<T> clazz, final FilterNode node);
/**
* 查询符合过滤条件记录的List集合 <br>
* 等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit} <br>
*
* @param <K> 主键泛型
* @param <T> Entity泛型
* @param clazz Entity类
* @param node FilterNode
*
* @return Entity的集合CompletableFuture
*/
public <K extends Serializable, T> CompletableFuture<Map<K, T>> queryMapAsync(final Class<T> clazz, final FilterNode node);
/** /**
* 查询符合过滤条件记录的Map集合, 主键值为key <br> * 查询符合过滤条件记录的Map集合, 主键值为key <br>
* 等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit} <br> * 等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit} <br>
@@ -1547,6 +1599,62 @@ public interface DataSource {
*/ */
public <K extends Serializable, T> CompletableFuture<Map<K, T>> queryMapAsync(final Class<T> clazz, final SelectColumn selects, final Stream<K> keyStream); public <K extends Serializable, T> CompletableFuture<Map<K, T>> queryMapAsync(final Class<T> clazz, final SelectColumn selects, final Stream<K> keyStream);
/**
* 查询符合过滤条件记录的Map集合, 主键值为key <br>
* 等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit} <br>
*
* @param <K> 主键泛型
* @param <T> Entity泛型
* @param clazz Entity类
* @param selects 指定字段
* @param bean FilterBean
*
* @return Entity的集合
*/
public <K extends Serializable, T> Map<K, T> queryMap(final Class<T> clazz, final SelectColumn selects, final FilterBean bean);
/**
* 查询符合过滤条件记录的List集合 <br>
* 等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit} <br>
*
* @param <K> 主键泛型
* @param <T> Entity泛型
* @param clazz Entity类
* @param selects 指定字段
* @param bean FilterBean
*
* @return Entity的集合CompletableFuture
*/
public <K extends Serializable, T> CompletableFuture<Map<K, T>> queryMapAsync(final Class<T> clazz, final SelectColumn selects, FilterBean bean);
/**
* 查询符合过滤条件记录的Map集合, 主键值为key <br>
* 等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit} <br>
*
* @param <K> 主键泛型
* @param <T> Entity泛型
* @param clazz Entity类
* @param selects 指定字段
* @param node FilterNode
*
* @return Entity的集合
*/
public <K extends Serializable, T> Map<K, T> queryMap(final Class<T> clazz, final SelectColumn selects, final FilterNode node);
/**
* 查询符合过滤条件记录的List集合 <br>
* 等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit} <br>
*
* @param <K> 主键泛型
* @param <T> Entity泛型
* @param clazz Entity类
* @param selects 指定字段
* @param node FilterNode
*
* @return Entity的集合CompletableFuture
*/
public <K extends Serializable, T> CompletableFuture<Map<K, T>> queryMapAsync(final Class<T> clazz, final SelectColumn selects, final FilterNode node);
/** /**
* 查询符合过滤条件记录的List集合 <br> * 查询符合过滤条件记录的List集合 <br>
* 等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit} <br> * 等价SQL: SELECT * FROM {table} WHERE {column} = {key} ORDER BY {flipper.sort} LIMIT {flipper.limit} <br>