/*
 * 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 com.wentch.redkale.source;

import static com.wentch.redkale.source.FilterNode.*;
import com.wentch.redkale.util.*;
import java.io.*;
import java.lang.reflect.*;
import java.net.*;
import java.sql.*;
import java.util.*;
import java.util.concurrent.atomic.*;
import java.util.function.*;
import java.util.logging.*;
import javax.annotation.*;
import javax.sql.*;
import javax.xml.stream.*;

/**
 *
 * @author zhangjx
 */
@SuppressWarnings("unchecked")
public final class DataDefaultSource implements DataSource, Nameable {

    public static final String DATASOURCE_CONFPATH = "DATASOURCE_CONFPATH";

    static final String JDBC_CONNECTIONMAX = "javax.persistence.connection.limit";

    static final String JDBC_URL = "javax.persistence.jdbc.url";

    static final String JDBC_USER = "javax.persistence.jdbc.user";

    static final String JDBC_PWD = "javax.persistence.jdbc.password";

    static final String JDBC_DRIVER = "javax.persistence.jdbc.driver";

    static final String JDBC_SOURCE = "javax.persistence.jdbc.source";

    private static final Flipper FLIPPER_ONE = new Flipper(1);

    final Logger logger = Logger.getLogger(DataDefaultSource.class.getSimpleName());

    final AtomicBoolean debug = new AtomicBoolean(logger.isLoggable(Level.FINEST));

    final String name;

    final URL conf;

    final boolean cacheForbidden;

    private final JDBCPoolSource readPool;

    private final JDBCPoolSource writePool;

    @Resource(name = "property.datasource.nodeid")
    private int nodeid;

    @Resource(name = "$")
    private DataSQLListener writeListener;

    @Resource(name = "$")
    private DataCacheListener cacheListener;

    private static class DataJDBCConnection extends DataConnection {

        private final Connection sqlconn;

        private DataJDBCConnection(Connection c) {
            super(c);
            this.sqlconn = c;
            try {
                this.sqlconn.setAutoCommit(true);
            } catch (Exception e) {
                //do nothing
            }
        }

        @Override
        public void close() {
            try {
                sqlconn.close();
            } catch (Exception e) {
                //do nothing
            }
        }

        @Override
        public boolean commit() {
            try {
                sqlconn.commit();
                return true;
            } catch (Exception e) {
                return false;
            }
        }

        @Override
        public void rollback() {
            try {
                sqlconn.rollback();
            } catch (Exception e) {
                //do nothing
            }
        }
    }

    private final Function<Class, List> fullloader = (t) -> queryList(t, (FilterNode) null);

    public DataDefaultSource() throws IOException {
        this("");
    }

    public DataDefaultSource(final String unitName) throws IOException {
        this(unitName, System.getProperty(DATASOURCE_CONFPATH) == null
                ? DataDefaultSource.class.getResource("/META-INF/persistence.xml")
                : new File(System.getProperty(DATASOURCE_CONFPATH)).toURI().toURL());
    }

    public DataDefaultSource(final String unitName, URL url) throws IOException {
        if (url == null) url = this.getClass().getResource("/persistence.xml");
        InputStream in = url.openStream();
        Map<String, Properties> map = loadProperties(in);
        Properties readprop = null;
        Properties writeprop = null;
        if (unitName != null) {
            readprop = map.get(unitName);
            writeprop = readprop;
            if (readprop == null) {
                readprop = map.get(unitName + ".read");
                writeprop = map.get(unitName + ".write");
            }
        }
        if ((unitName == null || unitName.isEmpty()) || readprop == null) {
            String key = null;
            for (Map.Entry<String, Properties> en : map.entrySet()) {
                key = en.getKey();
                readprop = en.getValue();
                writeprop = readprop;
                break;
            }
            if (key != null && (key.endsWith(".read") || key.endsWith(".write"))) {
                if (key.endsWith(".read")) {
                    writeprop = map.get(key.substring(0, key.lastIndexOf('.')) + ".write");
                } else {
                    readprop = map.get(key.substring(0, key.lastIndexOf('.')) + ".read");
                }
            }
        }
        if (readprop == null) throw new RuntimeException("not found persistence properties (unit:" + unitName + ")");
        this.name = unitName;
        this.conf = url;
        this.readPool = new JDBCPoolSource(this, "read", readprop);
        this.writePool = new JDBCPoolSource(this, "write", writeprop);
        this.cacheForbidden = "NONE".equalsIgnoreCase(readprop.getProperty("shared-cache-mode"));
    }

    public DataDefaultSource(String unitName, Properties readprop, Properties writeprop) {
        this.name = unitName;
        this.conf = null;
        this.readPool = new JDBCPoolSource(this, "read", readprop);
        this.writePool = new JDBCPoolSource(this, "write", writeprop);
        this.cacheForbidden = "NONE".equalsIgnoreCase(readprop.getProperty("shared-cache-mode"));
    }

    public static Map<String, DataDefaultSource> create(final InputStream in) {
        Map<String, Properties> map = loadProperties(in);
        Map<String, Properties[]> maps = new HashMap<>();
        map.entrySet().stream().forEach((en) -> {
            if (en.getKey().endsWith(".read") || en.getKey().endsWith(".write")) {
                String key = en.getKey().substring(0, en.getKey().lastIndexOf('.'));
                if (maps.containsKey(key)) return;
                boolean read = en.getKey().endsWith(".read");
                Properties rp = read ? en.getValue() : map.get(key + ".read");
                Properties wp = read ? map.get(key + ".write") : en.getValue();
                maps.put(key, new Properties[]{rp, wp});
            } else {
                maps.put(en.getKey(), new Properties[]{en.getValue(), en.getValue()});
            }
        });
        Map<String, DataDefaultSource> result = new HashMap<>();
        maps.entrySet().stream().forEach((en) -> {
            result.put(en.getKey(), new DataDefaultSource(en.getKey(), en.getValue()[0], en.getValue()[1]));
        });
        return result;
    }

    static Map<String, Properties> loadProperties(final InputStream in0) {
        final Map<String, Properties> map = new LinkedHashMap();
        Properties result = new Properties();
        boolean flag = false;
        try (final InputStream in = in0) {
            XMLStreamReader reader = XMLInputFactory.newFactory().createXMLStreamReader(in);
            while (reader.hasNext()) {
                int event = reader.next();
                if (event == XMLStreamConstants.START_ELEMENT) {
                    if ("persistence-unit".equalsIgnoreCase(reader.getLocalName())) {
                        if (!result.isEmpty()) result = new Properties();
                        map.put(reader.getAttributeValue(null, "name"), result);
                        flag = true;
                    } else if (flag && "property".equalsIgnoreCase(reader.getLocalName())) {
                        String name = reader.getAttributeValue(null, "name");
                        String value = reader.getAttributeValue(null, "value");
                        if (name == null) continue;
                        result.put(name, value);
                    } else if (flag && "shared-cache-mode".equalsIgnoreCase(reader.getLocalName())) {
                        result.put(reader.getLocalName(), reader.getElementText());
                    }
                }
            }
            in.close();
        } catch (Exception ex) {
            throw new RuntimeException(ex);
        }
        return map;
    }

    static ConnectionPoolDataSource createDataSource(Properties property) {
        try {
            return createDataSource(property.getProperty(JDBC_SOURCE, property.getProperty(JDBC_DRIVER)),
                    property.getProperty(JDBC_URL), property.getProperty(JDBC_USER), property.getProperty(JDBC_PWD));
        } catch (Exception ex) {
            throw new RuntimeException("(" + property + ") have no jdbc parameters", ex);
        }
    }

    static ConnectionPoolDataSource createDataSource(final String source0, String url, String user, String password) throws Exception {
        String source = source0;
        if (source0.contains("Driver")) {  //为了兼容JPA的配置文件
            switch (source0) {
                case "org.mariadb.jdbc.Driver":
                    source = "org.mariadb.jdbc.MySQLDataSource";
                    break;
                case "com.mysql.jdbc.Driver":
                    source = "com.mysql.jdbc.jdbc2.optional.MysqlConnectionPoolDataSource";
                    break;
                case "oracle.jdbc.driver.OracleDriver":
                    source = "oracle.jdbc.pool.OracleConnectionPoolDataSource";
                    break;
                case "com.microsoft.sqlserver.jdbc.SQLServerDriver":
                    source = "com.microsoft.sqlserver.jdbc.SQLServerConnectionPoolDataSource";
                    break;
            }
        }
        final Class clazz = Class.forName(source);
        Object pdsource = clazz.newInstance();
        Method seturlm;
        try {
            seturlm = clazz.getMethod("setUrl", String.class);
        } catch (Exception e) {
            seturlm = clazz.getMethod("setURL", String.class);
        }
        seturlm.invoke(pdsource, url);
        clazz.getMethod("setUser", String.class).invoke(pdsource, user);
        clazz.getMethod("setPassword", String.class).invoke(pdsource, password);
        return (ConnectionPoolDataSource) pdsource;
    }

    @Override
    public final String name() {
        return name;
    }

    @Override
    public DataConnection createReadConnection() {
        return new DataJDBCConnection(createReadSQLConnection());
    }

    @Override
    public DataConnection createWriteConnection() {
        return new DataJDBCConnection(createWriteSQLConnection());
    }

    public void close() {
        readPool.close();
        writePool.close();
    }

    public String getName() {
        return name;
    }

    private Connection createReadSQLConnection() {
        return readPool.poll();
    }

    private <T> Connection createWriteSQLConnection() {
        return writePool.poll();
    }

    private void closeSQLConnection(final Connection sqlconn) {
        if (sqlconn == null) return;
        try {
            sqlconn.close();
        } catch (Exception e) {
            logger.log(Level.WARNING, "closeSQLConnection abort", e);
        }
    }

    public <T> void execute(String... sqls) {
        Connection conn = createWriteSQLConnection();
        try {
            execute(conn, sqls);
        } finally {
            closeSQLConnection(conn);
        }
    }

    public <T> void execute(final DataConnection conn, String... sqls) {
        execute((Connection) conn.getConnection(), sqls);
    }

    private <T> void execute(final Connection conn, String... sqls) {
        if (sqls.length == 0) return;
        try {
            final Statement stmt = conn.createStatement();
            for (String sql : sqls) {
                stmt.execute(sql);
            }
            stmt.close();
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }

    private <T> EntityInfo<T> loadEntityInfo(Class<T> clazz) {
        return EntityInfo.load(clazz, this.nodeid, this.cacheForbidden, fullloader);
    }

    private <T extends FilterBean> FilterBeanNode loadFilterBeanNode(Class<T> clazz) {
        return FilterBeanNode.load(clazz, this.nodeid, this.cacheForbidden, fullloader);
    }

    /**
     * 将entity的对象全部加载到Cache中去，如果clazz没有被@javax.persistence.Cacheable注解则不做任何事
     * <p>
     * @param <T>
     * @param clazz
     */
    @Override
    public <T> void refreshCache(Class<T> clazz) {
        EntityInfo<T> info = loadEntityInfo(clazz);
        EntityCache<T> cache = info.getCache();
        if (cache == null) return;
        cache.fullLoad(queryList(clazz, (FilterNode) null));
    }

    //----------------------insertCache-----------------------------
    /**
     * 新增对象， 必须是Entity对象
     *
     * @param <T>
     * @param values
     */
    @Override
    public <T> void insert(T... values) {
        if (values.length == 0) return;
        final EntityInfo<T> info = loadEntityInfo((Class<T>) values[0].getClass());
        if (info.isVirtualEntity()) {
            insert(null, info, values);
            return;
        }
        Connection conn = createWriteSQLConnection();
        try {
            insert(conn, info, values);
        } finally {
            closeSQLConnection(conn);
        }
    }

    /**
     * 新增对象， 必须是Entity对象
     *
     * @param <T>
     * @param conn
     * @param values
     */
    @Override
    public <T> void insert(final DataConnection conn, T... values) {
        if (values.length == 0) return;
        final EntityInfo<T> info = loadEntityInfo((Class<T>) values[0].getClass());
        insert((Connection) conn.getConnection(), info, values);
    }

    private <T> void insert(final Connection conn, final EntityInfo<T> info, T... values) {
        if (values.length == 0) return;
        try {
            final EntityCache<T> cache = info.getCache();
            if (!info.isVirtualEntity()) {
                final String sql = info.insertSQL;
                final PreparedStatement prestmt = info.autoGenerated
                        ? conn.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS) : conn.prepareStatement(sql);
                final Class primaryType = info.getPrimary().type();
                final Attribute primary = info.getPrimary();
                final boolean distributed = info.distributed;
                Attribute<T, Serializable>[] attrs = info.insertAttributes;
                String[] sqls = null;
                if (distributed && !info.initedPrimaryValue && primaryType.isPrimitive()) {
                    synchronized (info) {
                        if (!info.initedPrimaryValue) {
                            Statement stmt = conn.createStatement();
                            ResultSet rs = stmt.executeQuery("SELECT MAX(" + info.getPrimarySQLColumn() + ") FROM " + info.getTable());
                            if (rs.next()) {
                                if (primaryType == int.class) {
                                    int v = rs.getInt(1) / info.allocationSize;
                                    if (v > info.primaryValue.get()) info.primaryValue.set(v);
                                } else {
                                    long v = rs.getLong(1) / info.allocationSize;
                                    if (v > info.primaryValue.get()) info.primaryValue.set(v);
                                }
                            }
                            rs.close();
                            stmt.close();
                            if (info.distributeTables != null) {
                                for (final Class t : info.distributeTables) {
                                    EntityInfo<T> infox = loadEntityInfo(t);
                                    stmt = conn.createStatement();
                                    rs = stmt.executeQuery("SELECT MAX(" + info.getPrimarySQLColumn() + ") FROM " + infox.getTable()); // 必须是同一字段名
                                    if (rs.next()) {
                                        if (primaryType == int.class) {
                                            int v = rs.getInt(1) / info.allocationSize;
                                            if (v > info.primaryValue.get()) info.primaryValue.set(v);
                                        } else {
                                            long v = rs.getLong(1) / info.allocationSize;
                                            if (v > info.primaryValue.get()) info.primaryValue.set(v);
                                        }
                                    }
                                    rs.close();
                                    stmt.close();
                                }
                            }
                            info.initedPrimaryValue = true;
                        }
                    }
                }
                if (writeListener == null) {
                    for (final T value : values) {
                        int i = 0;
                        if (distributed) info.createPrimaryValue(value);
                        for (Attribute<T, Serializable> attr : attrs) {
                            prestmt.setObject(++i, attr.get(value));
                        }
                        prestmt.addBatch();
                    }
                } else {
                    char[] sqlchars = sql.toCharArray();
                    sqls = new String[values.length];
                    String[] ps = new String[attrs.length];
                    int index = 0;
                    for (final T value : values) {
                        int i = 0;
                        if (distributed) info.createPrimaryValue(value);
                        for (Attribute<T, Serializable> attr : attrs) {
                            Object a = attr.get(value);
                            ps[i] = formatToString(a);
                            prestmt.setObject(++i, a);
                        }
                        prestmt.addBatch();
                        //-----------------------------
                        StringBuilder sb = new StringBuilder(128);
                        i = 0;
                        for (char ch : sqlchars) {
                            if (ch == '?') {
                                sb.append(ps[i++]);
                            } else {
                                sb.append(ch);
                            }
                        }
                        sqls[index++] = sb.toString();
                    }
                }
                prestmt.executeBatch();
                if (writeListener != null) writeListener.insert(sqls);
                if (info.autoGenerated) {
                    ResultSet set = prestmt.getGeneratedKeys();
                    int i = -1;
                    while (set.next()) {
                        if (primaryType == int.class) {
                            primary.set(values[++i], set.getInt(1));
                        } else if (primaryType == long.class) {
                            primary.set(values[++i], set.getLong(1));
                        } else {
                            primary.set(values[++i], set.getObject(1));
                        }
                    }
                    set.close();
                }
                prestmt.close();
                //------------------------------------------------------------
                if (debug.get()) {
                    char[] sqlchars = sql.toCharArray();
                    for (final T value : values) {
                        //-----------------------------
                        StringBuilder sb = new StringBuilder(128);
                        int i = 0;
                        for (char ch : sqlchars) {
                            if (ch == '?') {
                                sb.append(formatToString(attrs[i++].get(value)));
                            } else {
                                sb.append(ch);
                            }
                        }
                        logger.finest(info.getType().getSimpleName() + " insert sql=" + sb.toString().replaceAll("(\r|\n)", "\\n"));
                    }
                }
            }
            if (cache != null) {
                for (final T value : values) {
                    cache.insert(value);
                }
                if (cacheListener != null) cacheListener.insertCache(info.getType(), values);
            }
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }

    public <T> void insertCache(Class<T> clazz, T... values) {
        if (values.length == 0) return;
        final EntityInfo<T> info = EntityInfo.load(clazz, this.nodeid, this.cacheForbidden, fullloader);
        final EntityCache<T> cache = info.getCache();
        if (cache == null) return;
        for (T value : values) {
            cache.insert(value);
        }
    }

    //-------------------------deleteCache--------------------------
    /**
     * 删除对象， 必须是Entity对象
     *
     * @param <T>
     * @param values
     */
    @Override
    public <T> void delete(T... values) {
        if (values.length == 0) return;
        final EntityInfo<T> info = loadEntityInfo((Class<T>) values[0].getClass());
        if (info.isVirtualEntity()) {
            delete(null, info, values);
            return;
        }
        Connection conn = createWriteSQLConnection();
        try {
            delete(conn, info, values);
        } finally {
            closeSQLConnection(conn);
        }
    }

    @Override
    public <T> void delete(final DataConnection conn, T... values) {
        if (values.length == 0) return;
        final EntityInfo<T> info = loadEntityInfo((Class<T>) values[0].getClass());
        delete((Connection) conn.getConnection(), info, values);
    }

    private <T> void delete(final Connection conn, final EntityInfo<T> info, T... values) {
        if (values.length == 0) return;
        final Attribute primary = info.getPrimary();
        Serializable[] ids = new Serializable[values.length];
        int i = 0;
        for (final T value : values) {
            ids[i++] = (Serializable) primary.get(value);
        }
        delete(conn, info, ids);
    }

    @Override
    public <T> void delete(Class<T> clazz, Serializable... ids) {
        final EntityInfo<T> info = loadEntityInfo(clazz);
        if (info.isVirtualEntity()) {
            delete(null, info, ids);
            return;
        }
        Connection conn = createWriteSQLConnection();
        try {
            delete(conn, info, ids);
        } finally {
            closeSQLConnection(conn);
        }
    }

    @Override
    public <T> void delete(final DataConnection conn, Class<T> clazz, Serializable... ids) {
        delete((Connection) conn.getConnection(), loadEntityInfo(clazz), ids);
    }

    private <T> void delete(final Connection conn, final EntityInfo<T> info, Serializable... keys) {
        if (keys.length == 0) return;
        try {
            if (!info.isVirtualEntity()) {
                String sql = "DELETE FROM " + info.getTable() + " WHERE " + info.getPrimarySQLColumn()
                        + " IN " + formatToString(keys);
                if (debug.get()) logger.finest(info.getType().getSimpleName() + " delete sql=" + sql);
                final Statement stmt = conn.createStatement();
                stmt.execute(sql);
                stmt.close();
                if (writeListener != null) writeListener.delete(sql);
            }
            //------------------------------------
            final EntityCache<T> cache = info.getCache();
            if (cache == null) return;
            final Attribute<T, Serializable> attr = info.getPrimary();
            final Serializable[] keys2 = keys;
            Serializable[] ids = cache.delete((T t) -> Arrays.binarySearch(keys2, attr.get(t)) >= 0);
            if (cacheListener != null) cacheListener.deleteCache(info.getType(), ids);
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }

    @Override
    public <T> void delete(Class<T> clazz, FilterNode node) {
        final EntityInfo<T> info = loadEntityInfo(clazz);
        if (info.isVirtualEntity()) {
            delete(null, info, node);
            return;
        }
        Connection conn = createWriteSQLConnection();
        try {
            delete(conn, info, node);
        } finally {
            closeSQLConnection(conn);
        }
    }

    @Override
    public <T> void delete(final DataConnection conn, Class<T> clazz, FilterNode node) {
        delete((Connection) conn.getConnection(), loadEntityInfo(clazz), node);
    }

    private <T> void delete(final Connection conn, final EntityInfo<T> info, FilterNode node) {
        try {
            if (!info.isVirtualEntity()) {
                String sql = "DELETE FROM " + info.getTable() + node.createFilterSQLExpress(info, null);
                if (debug.get()) logger.finest(info.getType().getSimpleName() + " delete sql=" + sql);
                final Statement stmt = conn.createStatement();
                stmt.execute(sql);
                stmt.close();
                if (writeListener != null) writeListener.delete(sql);
            }
            //------------------------------------
            final EntityCache<T> cache = info.getCache();
            if (cache == null) return;
            Serializable[] ids = cache.delete(node.createFilterPredicate(info, null));
            if (cacheListener != null) cacheListener.deleteCache(info.getType(), ids);
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }

    public <T> void deleteCache(Class<T> clazz, Serializable... ids) {
        if (ids.length == 0) return;
        final EntityInfo<T> info = loadEntityInfo(clazz);
        final EntityCache<T> cache = info.getCache();
        if (cache == null) return;
        for (Serializable id : ids) {
            cache.delete(id);
        }
    }

    //------------------------update---------------------------
    /**
     * 更新对象， 必须是Entity对象
     *
     * @param <T>
     * @param values
     */
    @Override
    public <T> void update(T... values) {
        if (values.length == 0) return;
        final EntityInfo<T> info = loadEntityInfo((Class<T>) values[0].getClass());
        if (info.isVirtualEntity()) {
            update(null, info, values);
            return;
        }
        Connection conn = createWriteSQLConnection();
        try {
            update(conn, info, values);
        } finally {
            closeSQLConnection(conn);
        }
    }

    @Override
    public <T> void update(final DataConnection conn, T... values) {
        if (values.length == 0) return;
        final EntityInfo<T> info = loadEntityInfo((Class<T>) values[0].getClass());
        update((Connection) conn.getConnection(), info, values);
    }

    private <T> void update(final Connection conn, final EntityInfo<T> info, T... values) {
        try {
            Class clazz = info.getType();
            if (!info.isVirtualEntity()) {
                if (debug.get()) logger.finest(clazz.getSimpleName() + " update sql=" + info.updateSQL);
                final Attribute<T, Serializable> primary = info.getPrimary();
                final PreparedStatement prestmt = conn.prepareStatement(info.updateSQL);
                Attribute<T, Serializable>[] attrs = info.updateAttributes;
                String[] sqls = null;
                if (writeListener == null) {
                    for (final T value : values) {
                        int i = 0;
                        for (Attribute<T, Serializable> attr : attrs) {
                            prestmt.setObject(++i, attr.get(value));
                        }
                        prestmt.setObject(++i, primary.get(value));
                        prestmt.addBatch();
                    }
                } else {
                    char[] sqlchars = info.updateSQL.toCharArray();
                    sqls = new String[values.length];
                    String[] ps = new String[attrs.length];
                    int index = 0;
                    for (final T value : values) {
                        int i = 0;
                        for (Attribute<T, Serializable> attr : attrs) {
                            Object a = attr.get(value);
                            ps[i] = formatToString(a);
                            prestmt.setObject(++i, a);
                        }
                        prestmt.setObject(++i, primary.get(value));
                        prestmt.addBatch();
                        //-----------------------------
                        StringBuilder sb = new StringBuilder(128);
                        i = 0;
                        for (char ch : sqlchars) {
                            if (ch == '?') {
                                sb.append(ps[i++]);
                            } else {
                                sb.append(ch);
                            }
                        }
                        sqls[index++] = sb.toString();
                    }
                }
                prestmt.executeBatch();
                prestmt.close();
                if (writeListener != null) writeListener.update(sqls);
            }
            //---------------------------------------------------
            final EntityCache<T> cache = info.getCache();
            if (cache == null) return;
            for (final T value : values) {
                cache.update(value);
            }
            if (cacheListener != null) cacheListener.updateCache(clazz, values);
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 根据主键值更新对象的column对应的值， 必须是Entity Class
     *
     * @param <T>
     * @param clazz
     * @param id
     * @param column
     * @param value
     */
    @Override
    public <T> void updateColumn(Class<T> clazz, Serializable id, String column, Serializable value) {
        final EntityInfo<T> info = loadEntityInfo(clazz);
        if (info.isVirtualEntity()) {
            updateColumn(null, info, id, column, value);
            return;
        }
        Connection conn = createWriteSQLConnection();
        try {
            updateColumn(conn, info, id, column, value);
        } finally {
            closeSQLConnection(conn);
        }
    }

    @Override
    public <T> void updateColumn(DataConnection conn, Class<T> clazz, Serializable id, String column, Serializable value) {
        updateColumn((Connection) conn.getConnection(), loadEntityInfo(clazz), id, column, value);
    }

    private <T> void updateColumn(Connection conn, final EntityInfo<T> info, Serializable id, String column, Serializable value) {
        try {
            if (!info.isVirtualEntity()) {
                String sql = "UPDATE " + info.getTable() + " SET " + info.getSQLColumn(column) + " = "
                        + formatToString(value) + " WHERE " + info.getPrimarySQLColumn() + " = " + formatToString(id);
                if (debug.get()) logger.finest(info.getType().getSimpleName() + " update sql=" + sql);
                final Statement stmt = conn.createStatement();
                stmt.execute(sql);
                stmt.close();
                if (writeListener != null) writeListener.update(sql);
            }
            //---------------------------------------------------
            final EntityCache<T> cache = info.getCache();
            if (cache == null) return;
            T rs = cache.update(id, (Attribute<T, Serializable>) info.getAttribute(column), value);
            if (cacheListener != null) cacheListener.updateCache(info.getType(), rs);
        } catch (SQLException e) {
            throw new RuntimeException(e);
        } finally {
            if (conn != null) closeSQLConnection(conn);
        }
    }

    /**
     * 根据主键值给对象的column对应的值+incvalue， 必须是Entity Class
     *
     * @param <T>
     * @param clazz
     * @param id
     * @param column
     * @param incvalue
     */
    @Override
    public <T> void updateColumnIncrement(Class<T> clazz, Serializable id, String column, long incvalue) {
        final EntityInfo<T> info = loadEntityInfo(clazz);
        if (info.isVirtualEntity()) {
            updateColumnIncrement(null, info, id, column, incvalue);
            return;
        }
        Connection conn = createWriteSQLConnection();
        try {
            updateColumnIncrement(conn, info, id, column, incvalue);
        } finally {
            closeSQLConnection(conn);
        }
    }

    @Override
    public <T> void updateColumnIncrement(DataConnection conn, Class<T> clazz, Serializable id, String column, long incvalue) {
        updateColumnIncrement((Connection) conn.getConnection(), loadEntityInfo(clazz), id, column, incvalue);
    }

    private <T> void updateColumnIncrement(Connection conn, final EntityInfo<T> info, Serializable id, String column, long incvalue) {
        try {
            if (!info.isVirtualEntity()) {
                String col = info.getSQLColumn(column);
                String sql = "UPDATE " + info.getTable() + " SET " + col + " = " + col + " + (" + incvalue
                        + ") WHERE " + info.getPrimarySQLColumn() + " = " + formatToString(id);
                if (debug.get()) logger.finest(info.getType().getSimpleName() + " update sql=" + sql);
                final Statement stmt = conn.createStatement();
                stmt.execute(sql);
                stmt.close();
                if (writeListener != null) writeListener.update(sql);
            }
            //---------------------------------------------------
            final EntityCache<T> cache = info.getCache();
            if (cache == null) return;
            Attribute<T, Serializable> attr = info.getAttribute(column);
            T value = cache.updateColumnIncrement(id, attr, incvalue);
            if (value != null && cacheListener != null) cacheListener.updateCache(info.getType(), value);
        } catch (SQLException e) {
            throw new RuntimeException(e);
        } finally {
            if (conn != null) closeSQLConnection(conn);
        }
    }

    /**
     * 根据主键值给对象的column对应的值 & andvalue， 必须是Entity Class
     *
     * @param <T>
     * @param clazz
     * @param id
     * @param column
     * @param andvalue
     */
    @Override
    public <T> void updateColumnAnd(Class<T> clazz, Serializable id, String column, long andvalue) {
        final EntityInfo<T> info = loadEntityInfo(clazz);
        if (info.isVirtualEntity()) {
            updateColumnAnd(null, info, id, column, andvalue);
            return;
        }
        Connection conn = createWriteSQLConnection();
        try {
            updateColumnAnd(conn, info, id, column, andvalue);
        } finally {
            closeSQLConnection(conn);
        }
    }

    @Override
    public <T> void updateColumnAnd(DataConnection conn, Class<T> clazz, Serializable id, String column, long andvalue) {
        updateColumnAnd((Connection) conn.getConnection(), loadEntityInfo(clazz), id, column, andvalue);
    }

    private <T> void updateColumnAnd(Connection conn, final EntityInfo<T> info, Serializable id, String column, long andvalue) {
        try {
            if (!info.isVirtualEntity()) {
                String col = info.getSQLColumn(column);
                String sql = "UPDATE " + info.getTable() + " SET " + col + " = " + col + " & (" + andvalue
                        + ") WHERE " + info.getPrimarySQLColumn() + " = " + formatToString(id);
                if (debug.get()) logger.finest(info.getType().getSimpleName() + " update sql=" + sql);
                final Statement stmt = conn.createStatement();
                stmt.execute(sql);
                stmt.close();
                if (writeListener != null) writeListener.update(sql);
            }
            //---------------------------------------------------
            final EntityCache<T> cache = info.getCache();
            if (cache == null) return;
            Attribute<T, Serializable> attr = info.getAttribute(column);
            T value = cache.updateColumnAnd(id, attr, andvalue);
            if (value != null && cacheListener != null) cacheListener.updateCache(info.getType(), value);
        } catch (SQLException e) {
            throw new RuntimeException(e);
        } finally {
            if (conn != null) closeSQLConnection(conn);
        }
    }

    /**
     * 根据主键值给对象的column对应的值 | andvalue， 必须是Entity Class
     *
     * @param <T>
     * @param clazz
     * @param id
     * @param column
     * @param orvalue
     */
    @Override
    public <T> void updateColumnOr(Class<T> clazz, Serializable id, String column, long orvalue) {
        final EntityInfo<T> info = loadEntityInfo(clazz);
        if (info.isVirtualEntity()) {
            updateColumnOr(null, info, id, column, orvalue);
            return;
        }
        Connection conn = createWriteSQLConnection();
        try {
            updateColumnOr(conn, info, id, column, orvalue);
        } finally {
            closeSQLConnection(conn);
        }
    }

    @Override
    public <T> void updateColumnOr(DataConnection conn, Class<T> clazz, Serializable id, String column, long orvalue) {
        updateColumnOr((Connection) conn.getConnection(), loadEntityInfo(clazz), id, column, orvalue);
    }

    private <T> void updateColumnOr(Connection conn, final EntityInfo<T> info, Serializable id, String column, long orvalue) {
        try {
            if (!info.isVirtualEntity()) {
                String col = info.getSQLColumn(column);
                String sql = "UPDATE " + info.getTable() + " SET " + col + " = " + col + " | (" + orvalue
                        + ") WHERE " + info.getPrimarySQLColumn() + " = " + formatToString(id);
                if (debug.get()) logger.finest(info.getType().getSimpleName() + " update sql=" + sql);
                final Statement stmt = conn.createStatement();
                stmt.execute(sql);
                stmt.close();
                if (writeListener != null) writeListener.update(sql);
            }
            //---------------------------------------------------
            final EntityCache<T> cache = info.getCache();
            if (cache == null) return;
            Attribute<T, Serializable> attr = info.getAttribute(column);
            T value = cache.updateColumnOr(id, attr, orvalue);
            if (value != null && cacheListener != null) cacheListener.updateCache(info.getType(), value);
        } catch (SQLException e) {
            throw new RuntimeException(e);
        } finally {
            if (conn != null) closeSQLConnection(conn);
        }
    }

    /**
     * 更新对象指定的一些字段， 必须是Entity对象
     *
     * @param <T>
     * @param value
     * @param columns
     */
    @Override
    public <T> void updateColumns(final T value, final String... columns) {
        final EntityInfo<T> info = loadEntityInfo((Class<T>) value.getClass());
        if (info.isVirtualEntity()) {
            updateColumns(null, info, value, columns);
            return;
        }
        Connection conn = createWriteSQLConnection();
        try {
            updateColumns(conn, info, value, columns);
        } finally {
            closeSQLConnection(conn);
        }
    }

    @Override
    public <T> void updateColumns(final DataConnection conn, final T value, final String... columns) {
        updateColumns((Connection) conn.getConnection(), loadEntityInfo((Class<T>) value.getClass()), value, columns);
    }

    private <T> void updateColumns(final Connection conn, final EntityInfo<T> info, final T value, final String... columns) {
        if (value == null || columns.length < 1) return;
        try {
            final Class<T> clazz = (Class<T>) value.getClass();
            StringBuilder setsql = new StringBuilder();
            final Serializable id = info.getPrimary().get(value);
            final List<Attribute<T, Serializable>> attrs = new ArrayList<>();
            final boolean virtual = info.isVirtualEntity();
            for (String col : columns) {
                Attribute<T, Serializable> attr = info.getUpdateAttribute(col);
                if (attr == null) continue;
                attrs.add(attr);
                if (!virtual) {
                    if (setsql.length() > 0) setsql.append(',');
                    setsql.append(info.getSQLColumn(col)).append(" = ").append(formatToString(attr.get(value)));
                }
            }
            if (!virtual) {
                String sql = "UPDATE " + info.getTable() + " SET " + setsql
                        + " WHERE " + info.getPrimarySQLColumn() + " = " + formatToString(id);
                if (debug.get()) logger.finest(value.getClass().getSimpleName() + ": " + sql);
                final Statement stmt = conn.createStatement();
                stmt.execute(sql);
                stmt.close();
                if (writeListener != null) writeListener.update(sql);
            }
            //---------------------------------------------------
            final EntityCache<T> cache = info.getCache();
            if (cache == null) return;
            cache.update(value, attrs);
            if (cacheListener != null) cacheListener.updateCache(clazz, value);
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }

    public <T> void updateCache(Class<T> clazz, T... values) {
        if (values.length == 0) return;
        final EntityInfo<T> info = loadEntityInfo(clazz);
        final EntityCache<T> cache = info.getCache();
        if (cache == null) return;
        for (T value : values) {
            cache.update(value);
        }
    }

    public <T> void reloadCache(Class<T> clazz, Serializable... ids) {
        final EntityInfo<T> info = loadEntityInfo(clazz);
        final EntityCache<T> cache = info.getCache();
        if (cache == null) return;
        String column = info.getPrimary().field();
        for (Serializable id : ids) {
            Sheet<T> sheet = querySheet(false, clazz, null, FLIPPER_ONE, FilterNode.create(column, id), null);
            T value = sheet.isEmpty() ? null : sheet.list().get(0);
            if (value != null) cache.update(value);
        }
    }

    //-----------------------getNumberResult-----------------------------
    @Override
    public Number getNumberResult(final Class entityClass, final Reckon reckon, final String column) {
        return getNumberResult(entityClass, reckon, column, null, null);
    }

    @Override
    public Number getNumberResult(final Class entityClass, final Reckon reckon, final String column, FilterBean bean) {
        return getNumberResult(entityClass, reckon, column, null, bean);
    }

    @Override
    public Number getNumberResult(final Class entityClass, final Reckon reckon, final String column, FilterNode node) {
        return getNumberResult(entityClass, reckon, column, node, null);
    }

    private <T> Number getNumberResult(final Class<T> entityClass, final Reckon reckon, final String column, FilterNode node, FilterBean bean) {
        final Connection conn = createReadSQLConnection();
        try {
            final EntityInfo<T> info = loadEntityInfo(entityClass);
            if (node == null && bean != null) node = loadFilterBeanNode(bean.getClass());
            final EntityCache<T> cache = info.getCache();
            if (cache != null && (info.isVirtualEntity() || cache.isFullLoaded())) {
                Predicate<T> filter = node == null ? null : node.createFilterPredicate(info, bean);
                if (node == null || node.isJoinAllCached()) {
                    return cache.getNumberResult(reckon, column == null ? null : info.getAttribute(column), filter);
                }
            }
            final String sql = "SELECT " + reckon.getColumn((column == null || column.isEmpty() ? "*" : ("a." + column))) + " FROM " + info.getTable() + " a"
                    + (node == null ? "" : node.createFilterSQLExpress(info, bean));
            if (debug.get() && info.isLoggable(Level.FINEST)) logger.finest(entityClass.getSimpleName() + " single sql=" + sql);
            final PreparedStatement prestmt = conn.prepareStatement(sql);
            Number rs = null;
            ResultSet set = prestmt.executeQuery();
            if (set.next()) {
                rs = (Number) set.getObject(1);
            }
            set.close();
            prestmt.close();
            return rs;
        } catch (SQLException e) {
            throw new RuntimeException(e);
        } finally {
            if (conn != null) closeSQLConnection(conn);
        }
    }

    //-----------------------getMapResult-----------------------------
    @Override
    public <K extends Serializable, V extends Number> Map<K, V> getMapResult(Class entityClass, final String keyColumn, Reckon reckon, final String reckonColumn) {
        return getMapResult(entityClass, keyColumn, reckon, reckonColumn, null, null);
    }

    @Override
    public <K extends Serializable, V extends Number> Map<K, V> getMapResult(Class entityClass, final String keyColumn, Reckon reckon, final String reckonColumn, FilterBean bean) {
        return getMapResult(entityClass, keyColumn, reckon, reckonColumn, null, bean);
    }

    @Override
    public <K extends Serializable, V extends Number> Map<K, V> getMapResult(Class entityClass, final String keyColumn, Reckon reckon, final String reckonColumn, FilterNode node) {
        return getMapResult(entityClass, keyColumn, reckon, reckonColumn, node, null);
    }

    private <K extends Serializable, V extends Number> Map<K, V> getMapResult(final Class entityClass, final String keyColumn, final Reckon reckon, final String reckonColumn, FilterNode node, FilterBean bean) {
        final Connection conn = createReadSQLConnection();
        try {
            final EntityInfo info = loadEntityInfo(entityClass);
            if (node == null && bean != null) node = loadFilterBeanNode(bean.getClass());
            final EntityCache cache = info.getCache();
            if (cache != null && (info.isVirtualEntity() || cache.isFullLoaded())) {
                Predicate filter = node == null ? null : node.createFilterPredicate(info, bean);
                if (node == null || node.isJoinAllCached()) {
                    return cache.getMapResult(info.getAttribute(keyColumn), reckon, reckonColumn == null ? null : info.getAttribute(reckonColumn), filter);
                }
            }
            final String sqlkey = info.getSQLColumn(keyColumn);
            final String sql = "SELECT a." + sqlkey + ", " + reckon.getColumn((reckonColumn == null || reckonColumn.isEmpty() ? "*" : ("a." + reckonColumn)))
                    + " FROM " + info.getTable() + " a" + (node == null ? "" : node.createFilterSQLExpress(info, bean)) + " GROUP BY a." + sqlkey;
            if (debug.get() && info.isLoggable(Level.FINEST)) logger.finest(entityClass.getSimpleName() + " single sql=" + sql);
            final PreparedStatement prestmt = conn.prepareStatement(sql);
            Map<K, V> rs = new LinkedHashMap<>();
            ResultSet set = prestmt.executeQuery();
            ResultSetMetaData rsd = set.getMetaData();
            boolean smallint = rsd.getColumnType(1) == Types.SMALLINT;
            while (set.next()) {
                rs.put((K) (smallint ? set.getShort(1) : set.getObject(1)), (V) set.getObject(2));
            }
            set.close();
            prestmt.close();
            return rs;
        } catch (SQLException e) {
            throw new RuntimeException(e);
        } finally {
            if (conn != null) closeSQLConnection(conn);
        }
    }

    //-----------------------find----------------------------
    /**
     * 根据主键获取对象
     *
     * @param <T>
     * @param clazz
     * @param pk
     * @return
     */
    @Override
    public <T> T find(Class<T> clazz, Serializable pk) {
        return find(clazz, (SelectColumn) null, pk);
    }

    @Override
    public <T> T find(Class<T> clazz, final SelectColumn selects, Serializable pk) {
        String column = loadEntityInfo(clazz).getPrimary().field();
        Sheet<T> sheet = querySheet(clazz, selects, FLIPPER_ONE, FilterNode.create(column, pk));
        return sheet.isEmpty() ? null : sheet.list().get(0);
    }

    @Override
    public <T> T findByColumn(Class<T> clazz, String column, Serializable key) {
        return find(clazz, FilterNode.create(column, key));
    }

    @Override
    public <T> T find(final Class<T> clazz, final FilterBean bean) {
        Sheet<T> sheet = querySheet(clazz, FLIPPER_ONE, bean);
        return sheet.isEmpty() ? null : sheet.list().get(0);
    }

    @Override
    public <T> T find(final Class<T> clazz, final FilterNode node) {
        Sheet<T> sheet = querySheet(clazz, FLIPPER_ONE, node);
        return sheet.isEmpty() ? null : sheet.list().get(0);
    }

    @Override
    public <T> boolean exists(Class<T> clazz, Serializable pk) {
        return find(clazz, pk) != null;
    }

    @Override
    public <T> boolean exists(final Class<T> clazz, final FilterNode node) {
        return find(clazz, node) != null;
    }

    @Override
    public <T> boolean exists(final Class<T> clazz, final FilterBean bean) {
        return find(clazz, bean) != null;
    }

    //-----------------------list set----------------------------
    @Override
    public <T, V> HashSet<V> queryColumnSet(String selectedColumn, Class<T> clazz, String column, Serializable key) {
        return queryColumnSet(selectedColumn, clazz, FilterNode.create(column, key));
    }

    @Override
    public <T, V> HashSet<V> queryColumnSet(String selectedColumn, Class<T> clazz, FilterBean bean) {
        return new LinkedHashSet<>(queryColumnList(selectedColumn, clazz, bean));
    }

    @Override
    public <T, V> HashSet<V> queryColumnSet(String selectedColumn, Class<T> clazz, FilterNode node) {
        return new LinkedHashSet<>(queryColumnList(selectedColumn, clazz, node));
    }

    @Override
    public <T, V> List<V> queryColumnList(String selectedColumn, Class<T> clazz, String column, Serializable key) {
        return queryColumnList(selectedColumn, clazz, FilterNode.create(column, key));
    }

    @Override
    public <T, V> List<V> queryColumnList(String selectedColumn, Class<T> clazz, FilterBean bean) {
        return (List<V>) queryColumnSheet(selectedColumn, clazz, null, bean).list(true);
    }

    @Override
    public <T, V> List<V> queryColumnList(String selectedColumn, Class<T> clazz, FilterNode node) {
        return (List<V>) queryColumnSheet(selectedColumn, clazz, null, node).list(true);
    }

    /**
     * 根据过滤对象FilterBean查询对象集合
     *
     * @param <K>
     * @param <T>
     * @param clazz
     * @param bean
     * @return
     */
    @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> Map<K, T> queryMap(final Class<T> clazz, final FilterNode node) {
        return queryMap(clazz, null, node);
    }

    @Override
    public <K extends Serializable, T> Map<K, T> queryMap(final Class<T> clazz, final SelectColumn selects, final FilterBean bean) {
        return formatMap(clazz, querySheet(clazz, selects, null, bean).getRows());
    }

    @Override
    public <K extends Serializable, T> Map<K, T> queryMap(final Class<T> clazz, final SelectColumn selects, final FilterNode node) {
        return formatMap(clazz, querySheet(clazz, selects, null, node).getRows());
    }

    private <K extends Serializable, T> Map<K, T> formatMap(final Class<T> clazz, Collection<T> list) {
        Map<K, T> map = new LinkedHashMap<>();
        if (list == null || list.isEmpty()) return map;
        final Attribute<T, K> attr = (Attribute<T, K>) loadEntityInfo(clazz).getPrimary();
        for (T t : list) {
            map.put(attr.get(t), t);
        }
        return map;
    }

    /**
     * 根据指定字段值查询对象集合
     *
     * @param <T>
     * @param clazz
     * @param column
     * @param key
     * @return
     */
    @Override
    public <T> List<T> queryList(Class<T> clazz, String column, Serializable key) {
        return queryList(clazz, FilterNode.create(column, key));
    }

    /**
     * 根据过滤对象FilterBean查询对象集合
     *
     * @param <T>
     * @param clazz
     * @param bean
     * @return
     */
    @Override
    public <T> List<T> queryList(final Class<T> clazz, final FilterBean bean) {
        return queryList(clazz, null, bean);
    }

    @Override
    public <T> List<T> queryList(final Class<T> clazz, final FilterNode node) {
        return queryList(clazz, null, node);
    }

    /**
     * 根据过滤对象FilterBean查询对象集合， 对象只填充或排除SelectColumn指定的字段
     *
     * @param <T>
     * @param clazz
     * @param selects
     * @param bean
     * @return
     */
    @Override
    public <T> List<T> queryList(final Class<T> clazz, final SelectColumn selects, final FilterBean bean) {
        return querySheet(clazz, selects, null, bean).list(true);
    }

    @Override
    public <T> List<T> queryList(final Class<T> clazz, final SelectColumn selects, final FilterNode node) {
        return querySheet(clazz, selects, null, node).list(true);
    }

    //-----------------------sheet----------------------------
    /**
     * 根据指定参数查询对象某个字段的集合
     * <p>
     * @param <T>
     * @param <V>
     * @param selectedColumn
     * @param clazz
     * @param flipper
     * @param bean
     * @return
     */
    @Override
    public <T, V> Sheet<V> queryColumnSheet(String selectedColumn, Class<T> clazz, final Flipper flipper, final FilterBean bean) {
        return queryColumnSheet(selectedColumn, clazz, flipper, null, bean);
    }

    @Override
    public <T, V> Sheet<V> queryColumnSheet(String selectedColumn, Class<T> clazz, final Flipper flipper, final FilterNode node) {
        return queryColumnSheet(selectedColumn, clazz, flipper, node, null);
    }

    private <T, V> Sheet<V> queryColumnSheet(String selectedColumn, Class<T> clazz, final Flipper flipper, final FilterNode node, final FilterBean bean) {
        Sheet<T> sheet = querySheet(true, clazz, SelectColumn.createIncludes(selectedColumn), flipper, node, bean);
        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;
    }

    /**
     * 根据过滤对象FilterBean和翻页对象Flipper查询一页的数据
     *
     * @param <T>
     * @param clazz
     * @param flipper
     * @param bean
     * @return
     */
    @Override
    public <T> Sheet<T> querySheet(Class<T> clazz, final Flipper flipper, final FilterBean bean) {
        return querySheet(clazz, null, flipper, bean);
    }

    @Override
    public <T> Sheet<T> querySheet(Class<T> clazz, final Flipper flipper, final FilterNode node) {
        return querySheet(clazz, null, flipper, node);
    }

    /**
     * 根据过滤对象FilterBean和翻页对象Flipper查询一页的数据， 对象只填充或排除SelectColumn指定的字段
     *
     * @param <T>
     * @param clazz
     * @param selects
     * @param flipper
     * @param bean
     * @return
     */
    @Override
    public <T> Sheet<T> querySheet(Class<T> clazz, final SelectColumn selects, final Flipper flipper, final FilterBean bean) {
        return querySheet(true, clazz, selects, flipper, null, bean);
    }

    @Override
    public <T> Sheet<T> querySheet(Class<T> clazz, final SelectColumn selects, final Flipper flipper, final FilterNode node) {
        return querySheet(true, clazz, selects, flipper, node, null);
    }

    private <T> Sheet<T> querySheet(boolean readcache, Class<T> clazz, final SelectColumn selects, final Flipper flipper, FilterNode node, final FilterBean bean) {
        final EntityInfo<T> info = loadEntityInfo(clazz);
        final EntityCache<T> cache = info.getCache();
        if (node == null && bean != null) node = loadFilterBeanNode(bean.getClass());
        if (readcache && cache != null) {
            Predicate<T> filter = node == null ? null : node.createFilterPredicate(info, bean);
            if (node == null || node.isJoinAllCached()) {
                Sheet<T> sheet = cache.querySheet(selects, filter, flipper, FilterNode.createFilterComparator(info, flipper));
                if (!sheet.isEmpty() || info.isVirtualEntity() || cache.isFullLoaded()) return sheet;
            }
        }
        final Connection conn = createReadSQLConnection();
        try {
            final SelectColumn sels = selects;
            final List<T> list = new ArrayList();
            final String sql = "SELECT a.* FROM " + info.getTable() + " a"
                    + (node == null ? "" : node.createFilterSQLExpress(info, bean)) + createFilterSQLOrderBy(info, flipper);
            if (debug.get() && info.isLoggable(Level.FINEST))
                logger.finest(clazz.getSimpleName() + " query sql=" + sql + (flipper == null ? "" : (" LIMIT " + flipper.index() + "," + flipper.getSize())));
            final PreparedStatement ps = conn.prepareStatement(sql, ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY);
            final ResultSet set = ps.executeQuery();
            if (flipper != null && flipper.index() > 0) set.absolute(flipper.index());
            final int limit = flipper == null ? Integer.MAX_VALUE : flipper.getSize();
            int i = 0;
            long total;
            while (set.next()) {
                i++;
                list.add(info.getValue(sels, set));
                if (limit <= i) break;
            }
            if (flipper != null) {
                set.last();
                total = set.getRow();
            } else {
                total = list.size();
            }
            set.close();
            ps.close();
            return new Sheet<>(total, list);
        } catch (Exception ex) {
            throw new RuntimeException(ex);
        } finally {
            closeSQLConnection(conn);
        }
    }
}