diff --git a/src/org/redkale/source/DataSqlSource.java b/src/org/redkale/source/DataSqlSource.java
index 6fa2c00d4..56f1a07d2 100644
--- a/src/org/redkale/source/DataSqlSource.java
+++ b/src/org/redkale/source/DataSqlSource.java
@@ -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);
     }
 }