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

Browse Source
This commit is contained in:
Redkale
2018-05-04 11:18:46 +08:00
parent a5c11b5119
commit a8175d9e19
1 changed files with 530 additions and 4 deletions
Download Patch File Download Diff File Expand all files Collapse all files

534
src/org/redkale/source/DataSqlSource.java
View File

@@ -14,6 +14,7 @@ import java.util.concurrent.*;
import java.util.concurrent.atomic.*;
import java.util.function.*;
import java.util.logging.*;
import java.util.stream.Stream;
import javax.annotation.Resource;
import org.redkale.service.*;
import static org.redkale.source.DataSources.*;
@@ -61,7 +62,7 @@ public abstract class DataSqlSource<DBChannel> extends AbstractService implement
if (t != null) logger.log(Level.SEVERE, "CompletableFuture complete error", (Throwable) t);
};
protected final BiFunction<DataSource, Class, List> fullloader = (s, t) -> querySheet(false, false, t, null, null, (FilterNode) null).list(true);
protected final BiFunction<DataSource, Class, List> fullloader = (s, t) -> ((Sheet) querySheet(false, false, t, null, null, (FilterNode) null).join()).list(true);
@SuppressWarnings({"OverridableMethodCallInConstructor", "LeakingThisInConstructor"})
public DataSqlSource(String unitName, URL persistxml, Properties readprop, Properties writeprop) {
@@ -116,9 +117,12 @@ public abstract class DataSqlSource<DBChannel> extends AbstractService implement
//查询单条记录的单个字段
protected abstract <T> CompletableFuture<Serializable> findColumnDB(final EntityInfo<T> info, final String sql, final boolean onlypk, final String column, final Serializable defValue);
//查询单条记录的单个字段
//判断记录是否存在
protected abstract <T> CompletableFuture<Boolean> existsDB(final EntityInfo<T> info, final String sql, final boolean onlypk);
//查询一页数据
protected abstract <T> CompletableFuture<Sheet<T>> querySheetDB(final EntityInfo<T> info, final boolean needtotal, final SelectColumn selects, final Flipper flipper, final FilterNode node);
@Override
protected ExecutorService getExecutor() {
return executor;
@@ -741,7 +745,529 @@ public abstract class DataSqlSource<DBChannel> extends AbstractService implement
return existsDB(info, sql, false);
}
protected <T> Sheet<T> querySheet(final boolean readcache, final boolean needtotal, final Class<T> clazz, final SelectColumn selects, final Flipper flipper, final FilterNode node) {
return null;
//-----------------------list set----------------------------
@Override
public <T, V extends Serializable> HashSet<V> queryColumnSet(final String selectedColumn, Class<T> clazz, String column, Serializable key) {
return new LinkedHashSet<>(queryColumnList(selectedColumn, clazz, null, FilterNode.create(column, key)));
}
@Override
public <T, V extends Serializable> CompletableFuture<HashSet<V>> queryColumnSetAsync(final String selectedColumn, Class<T> clazz, String column, Serializable key) {
return queryColumnListAsync(selectedColumn, clazz, null, FilterNode.create(column, key)).thenApply((list) -> new LinkedHashSet(list));
}
@Override
public <T, V extends Serializable> HashSet<V> queryColumnSet(final String selectedColumn, final Class<T> clazz, final FilterBean bean) {
return new LinkedHashSet<>(queryColumnList(selectedColumn, clazz, null, FilterNodeBean.createFilterNode(bean)));
}
@Override
public <T, V extends Serializable> CompletableFuture<HashSet<V>> queryColumnSetAsync(final String selectedColumn, final Class<T> clazz, final FilterBean bean) {
return queryColumnListAsync(selectedColumn, clazz, null, FilterNodeBean.createFilterNode(bean)).thenApply((list) -> new LinkedHashSet(list));
}
@Override
public <T, V extends Serializable> HashSet<V> queryColumnSet(String selectedColumn, Class<T> clazz, FilterNode node) {
return new LinkedHashSet<>(queryColumnList(selectedColumn, clazz, null, node));
}
@Override
public <T, V extends Serializable> CompletableFuture<HashSet<V>> queryColumnSetAsync(final String selectedColumn, final Class<T> clazz, final FilterNode node) {
return queryColumnListAsync(selectedColumn, clazz, null, node).thenApply((list) -> new LinkedHashSet(list));
}
@Override
public <T, V extends Serializable> List<V> queryColumnList(final String selectedColumn, final Class<T> clazz, final String column, final Serializable key) {
return queryColumnList(selectedColumn, clazz, null, FilterNode.create(column, key));
}
@Override
public <T, V extends Serializable> CompletableFuture<List<V>> queryColumnListAsync(final String selectedColumn, final Class<T> clazz, final String column, final Serializable key) {
return queryColumnListAsync(selectedColumn, clazz, null, FilterNode.create(column, key));
}
@Override
public <T, V extends Serializable> List<V> queryColumnList(final String selectedColumn, final Class<T> clazz, final FilterBean bean) {
return queryColumnList(selectedColumn, clazz, null, FilterNodeBean.createFilterNode(bean));
}
@Override
public <T, V extends Serializable> CompletableFuture<List<V>> queryColumnListAsync(final String selectedColumn, final Class<T> clazz, final FilterBean bean) {
return queryColumnListAsync(selectedColumn, clazz, null, FilterNodeBean.createFilterNode(bean));
}
@Override
public <T, V extends Serializable> List<V> queryColumnList(final String selectedColumn, final Class<T> clazz, final FilterNode node) {
return queryColumnList(selectedColumn, clazz, null, node);
}
@Override
public <T, V extends Serializable> CompletableFuture<List<V>> queryColumnListAsync(final String selectedColumn, final Class<T> clazz, final FilterNode node) {
return queryColumnListAsync(selectedColumn, clazz, null, node);
}
@Override
public <T, V extends Serializable> List<V> queryColumnList(final String selectedColumn, final Class<T> clazz, final Flipper flipper, final FilterBean bean) {
return queryColumnList(selectedColumn, clazz, flipper, FilterNodeBean.createFilterNode(bean));
}
@Override
public <T, V extends Serializable> CompletableFuture<List<V>> queryColumnListAsync(final String selectedColumn, final Class<T> clazz, final Flipper flipper, final FilterBean bean) {
return queryColumnListAsync(selectedColumn, clazz, flipper, FilterNodeBean.createFilterNode(bean));
}
@Override
public <T, V extends Serializable> List<V> queryColumnList(final String selectedColumn, final Class<T> clazz, final Flipper flipper, final FilterNode node) {
final List<T> list = queryList(clazz, SelectColumn.createIncludes(selectedColumn), flipper, node);
final List<V> rs = new ArrayList<>();
if (list.isEmpty()) return rs;
final EntityInfo<T> info = loadEntityInfo(clazz);
final Attribute<T, V> selected = (Attribute<T, V>) info.getAttribute(selectedColumn);
for (T t : list) {
rs.add(selected.get(t));
}
return rs;
}
@Override
public <T, V extends Serializable> CompletableFuture<List<V>> queryColumnListAsync(final String selectedColumn, final Class<T> clazz, final Flipper flipper, final FilterNode node) {
return queryListAsync(clazz, SelectColumn.createIncludes(selectedColumn), flipper, node).thenApply((List<T> list) -> {
final List<V> rs = new ArrayList<>();
if (list.isEmpty()) return rs;
final EntityInfo<T> info = loadEntityInfo(clazz);
final Attribute<T, V> selected = (Attribute<T, V>) info.getAttribute(selectedColumn);
for (T t : list) {
rs.add(selected.get(t));
}
return rs;
});
}
/**
* 根据指定参数查询对象某个字段的集合
* <p>
* @param <T> Entity类的泛型
* @param <V> 字段值的类型
* @param selectedColumn 字段名
* @param clazz Entity类
* @param flipper 翻页对象
* @param bean 过滤Bean
*
* @return 字段集合
*/
@Override
public <T, V extends Serializable> Sheet<V> queryColumnSheet(final String selectedColumn, Class<T> clazz, final Flipper flipper, final FilterBean bean) {
return queryColumnSheet(selectedColumn, clazz, flipper, FilterNodeBean.createFilterNode(bean));
}
@Override
public <T, V extends Serializable> CompletableFuture<Sheet<V>> queryColumnSheetAsync(final String selectedColumn, final Class<T> clazz, final Flipper flipper, final FilterBean bean) {
return queryColumnSheetAsync(selectedColumn, clazz, flipper, FilterNodeBean.createFilterNode(bean));
}
@Override
public <T, V extends Serializable> Sheet<V> queryColumnSheet(final String selectedColumn, final Class<T> clazz, final Flipper flipper, final FilterNode node) {
Sheet<T> sheet = querySheet(clazz, SelectColumn.createIncludes(selectedColumn), flipper, node);
final Sheet<V> rs = new Sheet<>();
if (sheet.isEmpty()) return rs;
rs.setTotal(sheet.getTotal());
final EntityInfo<T> info = loadEntityInfo(clazz);
final Attribute<T, V> selected = (Attribute<T, V>) info.getAttribute(selectedColumn);
final List<V> list = new ArrayList<>();
for (T t : sheet.getRows()) {
list.add(selected.get(t));
}
rs.setRows(list);
return rs;
}
@Override
public <T, V extends Serializable> CompletableFuture<Sheet<V>> queryColumnSheetAsync(final String selectedColumn, final Class<T> clazz, final Flipper flipper, final FilterNode node) {
return querySheetAsync(clazz, SelectColumn.createIncludes(selectedColumn), flipper, node).thenApply((Sheet<T> sheet) -> {
final Sheet<V> rs = new Sheet<>();
if (sheet.isEmpty()) return rs;
rs.setTotal(sheet.getTotal());
final EntityInfo<T> info = loadEntityInfo(clazz);
final Attribute<T, V> selected = (Attribute<T, V>) info.getAttribute(selectedColumn);
final List<V> list = new ArrayList<>();
for (T t : sheet.getRows()) {
list.add(selected.get(t));
}
rs.setRows(list);
return rs;
});
}
/**
* 查询符合过滤条件记录的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 keyStream 主键Stream
*
* @return Entity的集合
*/
@Override
public <K extends Serializable, T> Map<K, T> queryMap(final Class<T> clazz, final Stream<K> keyStream) {
return queryMap(clazz, null, keyStream);
}
@Override
public <K extends Serializable, T> CompletableFuture<Map<K, T>> queryMapAsync(final Class<T> clazz, final Stream<K> keyStream) {
return queryMapAsync(clazz, null, 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的集合
*/
@Override
public <K extends Serializable, T> Map<K, T> queryMap(final Class<T> clazz, final FilterBean bean) {
return queryMap(clazz, null, FilterNodeBean.createFilterNode(bean));
}
@Override
public <K extends Serializable, T> CompletableFuture<Map<K, T>> queryMapAsync(final Class<T> clazz, final FilterBean bean) {
return queryMapAsync(clazz, null, FilterNodeBean.createFilterNode(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的集合
*/
@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 queryMapAsync(clazz, null, node);
}
/**
* 查询符合过滤条件记录的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 keyStream 主键Stream
*
* @return Entity的集合
*/
@Override
public <K extends Serializable, T> Map<K, T> queryMap(final Class<T> clazz, final SelectColumn selects, final Stream<K> keyStream) {
if (keyStream == null) return new LinkedHashMap<>();
final EntityInfo<T> info = loadEntityInfo(clazz);
final ArrayList<K> ids = new ArrayList<>();
keyStream.forEach(k -> ids.add(k));
final Attribute<T, Serializable> primary = info.primary;
List<T> rs = queryList(clazz, FilterNode.create(primary.field(), ids));
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 Stream<K> keyStream) {
if (keyStream == null) return CompletableFuture.completedFuture(new LinkedHashMap<>());
final EntityInfo<T> info = loadEntityInfo(clazz);
final ArrayList<K> ids = new ArrayList<>();
keyStream.forEach(k -> ids.add(k));
final Attribute<T, Serializable> primary = info.primary;
return queryListAsync(clazz, FilterNode.create(primary.field(), ids)).thenApply((List<T> rs) -> {
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;
});
}
/**
* 查询符合过滤条件记录的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 queryMapAsync(clazz, selects, FilterNodeBean.createFilterNode(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的集合
*/
@Override
public <K extends Serializable, T> Map<K, T> queryMap(final Class<T> clazz, final SelectColumn selects, final FilterNode node) {
List<T> rs = queryList(clazz, selects, node);
final EntityInfo<T> info = loadEntityInfo(clazz);
final Attribute<T, Serializable> primary = info.primary;
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 queryListAsync(clazz, selects, node).thenApply((List<T> rs) -> {
final EntityInfo<T> info = loadEntityInfo(clazz);
final Attribute<T, Serializable> primary = info.primary;
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;
});
}
/**
* 根据指定字段值查询对象集合
*
* @param <T> Entity类的泛型
* @param clazz Entity类
* @param column 过滤字段名
* @param key 过滤字段值
*
* @return Entity对象的集合
*/
@Override
public <T> List<T> queryList(final Class<T> clazz, final String column, final Serializable key) {
return queryList(clazz, (SelectColumn) null, null, FilterNode.create(column, key));
}
@Override
public <T> CompletableFuture<List<T>> queryListAsync(final Class<T> clazz, final String column, final Serializable key) {
return queryListAsync(clazz, (SelectColumn) null, null, FilterNode.create(column, key));
}
/**
* 根据过滤对象FilterBean查询对象集合
*
* @param <T> Entity类的泛型
* @param clazz Entity类
* @param bean 过滤Bean
*
* @return Entity对象集合
*/
@Override
public <T> List<T> queryList(final Class<T> clazz, final FilterBean bean) {
return queryList(clazz, (SelectColumn) null, null, FilterNodeBean.createFilterNode(bean));
}
@Override
public <T> CompletableFuture<List<T>> queryListAsync(final Class<T> clazz, final FilterBean bean) {
return queryListAsync(clazz, (SelectColumn) null, null, FilterNodeBean.createFilterNode(bean));
}
@Override
public <T> List<T> queryList(final Class<T> clazz, final FilterNode node) {
return queryList(clazz, (SelectColumn) null, null, node);
}
@Override
public <T> CompletableFuture<List<T>> queryListAsync(final Class<T> clazz, final FilterNode node) {
return queryListAsync(clazz, (SelectColumn) null, null, node);
}
/**
* 根据过滤对象FilterBean查询对象集合， 对象只填充或排除SelectField指定的字段
*
* @param <T> Entity类的泛型
* @param clazz Entity类
* @param selects 收集的字段
* @param bean 过滤Bean
*
* @return Entity对象的集合
*/
@Override
public <T> List<T> queryList(final Class<T> clazz, final SelectColumn selects, final FilterBean bean) {
return queryList(clazz, selects, null, FilterNodeBean.createFilterNode(bean));
}
@Override
public <T> CompletableFuture<List<T>> queryListAsync(final Class<T> clazz, SelectColumn selects, final FilterBean bean) {
return queryListAsync(clazz, selects, null, FilterNodeBean.createFilterNode(bean));
}
@Override
public <T> List<T> queryList(final Class<T> clazz, final SelectColumn selects, final FilterNode node) {
return queryList(clazz, selects, null, node);
}
@Override
public <T> CompletableFuture<List<T>> queryListAsync(final Class<T> clazz, SelectColumn selects, final FilterNode node) {
return queryListAsync(clazz, selects, null, node);
}
@Override
public <T> List<T> queryList(final Class<T> clazz, final Flipper flipper, final String column, final Serializable key) {
return queryList(clazz, null, flipper, FilterNode.create(column, key));
}
@Override
public <T> CompletableFuture<List<T>> queryListAsync(final Class<T> clazz, final Flipper flipper, final String column, final Serializable key) {
return queryListAsync(clazz, null, flipper, FilterNode.create(column, key));
}
@Override
public <T> List<T> queryList(final Class<T> clazz, final Flipper flipper, final FilterBean bean) {
return queryList(clazz, null, flipper, FilterNodeBean.createFilterNode(bean));
}
@Override
public <T> CompletableFuture<List<T>> queryListAsync(final Class<T> clazz, final Flipper flipper, final FilterBean bean) {
return queryListAsync(clazz, null, flipper, FilterNodeBean.createFilterNode(bean));
}
@Override
public <T> List<T> queryList(final Class<T> clazz, final Flipper flipper, final FilterNode node) {
return queryList(clazz, null, flipper, node);
}
@Override
public <T> CompletableFuture<List<T>> queryListAsync(final Class<T> clazz, final Flipper flipper, final FilterNode node) {
return queryListAsync(clazz, null, flipper, node);
}
@Override
public <T> List<T> queryList(final Class<T> clazz, final SelectColumn selects, final Flipper flipper, final FilterBean bean) {
return queryList(clazz, selects, flipper, FilterNodeBean.createFilterNode(bean));
}
@Override
public <T> CompletableFuture<List<T>> queryListAsync(final Class<T> clazz, final SelectColumn selects, final Flipper flipper, final FilterBean bean) {
return queryListAsync(clazz, selects, flipper, FilterNodeBean.createFilterNode(bean));
}
@Override
public <T> List<T> queryList(final Class<T> clazz, final SelectColumn selects, final Flipper flipper, final FilterNode node) {
return querySheet(true, false, clazz, selects, flipper, node).join().list(true);
}
@Override
public <T> CompletableFuture<List<T>> queryListAsync(final Class<T> clazz, final SelectColumn selects, final Flipper flipper, final FilterNode node) {
return querySheet(true, false, clazz, selects, flipper, node).thenApply((rs) -> rs.list(true));
}
//-----------------------sheet----------------------------
/**
* 根据过滤对象FilterBean和翻页对象Flipper查询一页的数据
*
* @param <T> Entity类的泛型
* @param clazz Entity类
* @param flipper 翻页对象
* @param bean 过滤Bean
*
* @return Entity对象的集合
*/
@Override
public <T> Sheet<T> querySheet(final Class<T> clazz, final Flipper flipper, final FilterBean bean) {
return querySheet(clazz, null, flipper, FilterNodeBean.createFilterNode(bean));
}
@Override
public <T> CompletableFuture<Sheet<T>> querySheetAsync(final Class<T> clazz, final Flipper flipper, final FilterBean bean) {
return querySheetAsync(clazz, null, flipper, FilterNodeBean.createFilterNode(bean));
}
@Override
public <T> Sheet<T> querySheet(final Class<T> clazz, final Flipper flipper, final FilterNode node) {
return querySheet(clazz, null, flipper, node);
}
@Override
public <T> CompletableFuture<Sheet<T>> querySheetAsync(final Class<T> clazz, final Flipper flipper, final FilterNode node) {
return querySheetAsync(clazz, null, flipper, node);
}
/**
* 根据过滤对象FilterBean和翻页对象Flipper查询一页的数据， 对象只填充或排除SelectField指定的字段
*
* @param <T> Entity类的泛型
* @param clazz Entity类
* @param selects 收集的字段集合
* @param flipper 翻页对象
* @param bean 过滤Bean
*
* @return Entity对象的集合
*/
@Override
public <T> Sheet<T> querySheet(final Class<T> clazz, final SelectColumn selects, final Flipper flipper, final FilterBean bean) {
return querySheet(clazz, selects, flipper, FilterNodeBean.createFilterNode(bean));
}
@Override
public <T> CompletableFuture<Sheet<T>> querySheetAsync(final Class<T> clazz, final SelectColumn selects, final Flipper flipper, final FilterBean bean) {
return querySheetAsync(clazz, selects, flipper, FilterNodeBean.createFilterNode(bean));
}
@Override
public <T> Sheet<T> querySheet(final Class<T> clazz, final SelectColumn selects, final Flipper flipper, final FilterNode node) {
return querySheet(true, true, clazz, selects, flipper, node).join();
}
@Override
public <T> CompletableFuture<Sheet<T>> querySheetAsync(final Class<T> clazz, final SelectColumn selects, final Flipper flipper, final FilterNode node) {
if (isAysnc()) return querySheet(true, true, clazz, selects, flipper, node);
return CompletableFuture.supplyAsync(() -> querySheet(true, true, clazz, selects, flipper, node).join(), getExecutor());
}
protected <T> CompletableFuture<Sheet<T>> querySheet(final boolean readcache, final boolean needtotal, final Class<T> clazz, final SelectColumn selects, final Flipper flipper, final FilterNode node) {
final EntityInfo<T> info = loadEntityInfo(clazz);
final EntityCache<T> cache = info.getCache();
if (readcache && cache != null && cache.isFullLoaded()) {
if (node == null || node.isCacheUseable(this)) {
if (info.isLoggable(logger, Level.FINEST)) logger.finest(clazz.getSimpleName() + " cache query predicate = " + (node == null ? null : node.createPredicate(cache)));
return CompletableFuture.completedFuture(cache.querySheet(needtotal, selects, flipper, node));
}
}
return querySheetDB(info, needtotal, selects, flipper, node);
}
}