Application: gvSIG desktop

package org.gvsig.fmap.dal.store.jdbc2.impl;

import java.sql.PreparedStatement;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.sql.Statement;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import org.gvsig.fmap.dal.exception.DataException;

import org.gvsig.fmap.dal.feature.FeatureAttributeDescriptor;

import org.gvsig.fmap.dal.store.jdbc.exception.JDBCExecutePreparedSQLException;

import org.gvsig.fmap.dal.store.jdbc2.JDBCConnection;

import org.gvsig.fmap.dal.store.jdbc2.JDBCHelper;

import org.gvsig.fmap.dal.store.jdbc2.JDBCUtils;

import org.gvsig.fmap.dal.store.jdbc2.ResulSetControler;

import org.gvsig.fmap.dal.store.jdbc2.spi.JDBCHelperBase;

import org.gvsig.fmap.dal.store.jdbc2.spi.JDBCSQLBuilderBase;

import org.gvsig.tools.dispose.Disposable;

import org.gvsig.tools.dispose.DisposeUtils;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class ResulSetControlerBase implements ResulSetControler {

    final static private Logger LOGGER = LoggerFactory.getLogger(ResulSetControlerBase.class);

    public class ResultSetEntryBase implements ResultSetEntry {

        private ResultSet resultSet = null;

        private final int id;

        private long lastUse = 0;

        private final String sql;

        private final FeatureAttributeDescriptor[] columns;

        private final String[] extraValueNames;

        private Throwable closeCause ;

        private final String connId;

        private final String hexId;

        private final JDBCConnection conn;

        public ResultSetEntryBase(JDBCConnection conn, ResultSet resulSet, String sql, FeatureAttributeDescriptor[] columns, String[] extraValueNames) {

            this.conn = conn;

            this.closeCause = null;

            this.resultSet = resulSet;

            this.connId = JDBCUtils.getConnId(this.resultSet);

            this.hexId = JDBCUtils.getHexId(this);

            this.id = nextid++;

            this.sql = sql;

            this.columns = columns;

            this.extraValueNames = extraValueNames;

            used();

            synchronized(resulSets){

                resulSets.put(this.getID(), this);

            }

            if( LOGGER.isDebugEnabled() ) {

                LOGGER.debug("["+JDBCUtils.getConnId(resulSet)+"] ResultSetEntryBase "+this.hexId+" "+sql);

            }

            LOGGER.debug(((JDBCHelperBase)helper).getConnectionProviderStatus());

        }

        private void used() {

            lastUse = System.currentTimeMillis();

        }

        @Override

        public ResultSet get() {

            used();

            return resultSet;

        }

        @Override

        public int getID() {

            return this.id;

        }

        @Override

        public boolean isZombie() {

            if( this.resultSet == null ) {

                return true;

            }

            return System.currentTimeMillis() - lastUse > mlsecondsToZombie;

        }

        @Override

        public String getSQL() {

            return this.sql;

        }

        @Override

        public String[] getExtraValueNames() {

            return this.extraValueNames;

        }

        @Override

        public FeatureAttributeDescriptor[] getColumns() {

            return this.columns;

        }

        @Override

        public Object getObject(int columnIndex) throws SQLException {

            used();

            return this.resultSet.getObject(columnIndex);

        }

        @Override

        public byte[] getBytes(int columnIndex) throws SQLException {

            used();

            return this.resultSet.getBytes(columnIndex);

        }

        @Override

        public boolean next() throws SQLException {

            if( this.closeCause!=null ) {

                LOGGER.debug("["+this.connId+"] ResultSetEntryBase already closed "+this.hexId);

                throw new IllegalStateException("ResultSetEntryBase already closed, connId="+this.connId+", id="+this.hexId+" (sql="+sql+")", closeCause);

            }

            return this.resultSet.next();

        }

        @Override

        public void close() throws Exception {

            if( LOGGER.isDebugEnabled() ) {

                LOGGER.debug("["+this.connId+"] ResultSetEntryBase close "+this.hexId);

            }

            if( this.resultSet == null ) {

                // Already close

                return;

            }

            this.closeCause = new Throwable();

            Statement st = null;

            try {

                synchronized(resulSets){

                    resulSets.remove(this.getID());

                }

                st = this.resultSet.getStatement();

            } catch(Exception ex) {

                LOGGER.warn("Problems closing ResulSetEntryBase.",ex);

            }

            JDBCUtils.closeQuietly(this.resultSet);

            JDBCUtils.closeQuietly(st);

            this.conn.closeQuietly();

            this.resultSet = null;

            LOGGER.debug(

                    "Close ResulSetEntryBase id {} (total {})",

                    this.getID(),

                    getOpenCount()

            );

            LOGGER.debug(((JDBCHelperBase)helper).getConnectionProviderStatus());

            pack();

        }

    }

    private int nextid = 1;

    private final Map<Integer, ResultSetEntryBase> resulSets;

    private long mlsecondsToZombie = 1000 * 60 * 10; // 10 Min

    private JDBCHelper helper = null;

    public ResulSetControlerBase(JDBCHelper helper) {

        this.helper = helper;

        this.resulSets = new HashMap<>();

        this.nextid = 1;

    }

    @Override

    public long getTimeToZombie() {

        return mlsecondsToZombie;

    }

    @Override

    public void setTimeToZombie(long mlSeconds) {

        mlsecondsToZombie = mlSeconds;

    }

    @Override

    public void close() throws Exception {

        this.closeAll();

        this.helper = null;

        this.resulSets.clear();

        this.nextid = -10;

    }

    @Override

    public ResultSetEntryBase create(

            String sql,

            int fetchSize,

            FeatureAttributeDescriptor[] columns,

            String[] extraValueNames) throws DataException {

        return create(sql, null, fetchSize, columns, extraValueNames);

    }

    @Override

    public synchronized ResultSetEntryBase create(

            String sql,

            List<Object> values,

            int fetchSize,

            FeatureAttributeDescriptor[] columns,

            String[] extraValueNames) throws DataException {

        this.pack();

        ResultSet rs = null;

        JDBCConnection conn = null;

        PreparedStatement st = null;

        Disposable paramsDisposer = null;

        try {

            conn = helper.getConnection();

            conn.begin();

            st = conn.prepareStatement(sql);

            JDBCSQLBuilderBase sqlbuilder = helper.createSQLBuilder();

            paramsDisposer = sqlbuilder.setStatementParameters(st, values, helper.getGeometrySupportType());

            if (fetchSize > 0) {

                // See parameter "SelectMethod" of SQL Server Connection Properties

                // https://docs.oracle.com/cd/E13157_01/wlevs/docs30/jdbc_drivers/mssqlserver.html

                st.setFetchSize(fetchSize);

            }

            rs = JDBCUtils.executeQuery(st, sql);

            if (fetchSize > 0) {

                rs.setFetchSize(fetchSize);

            }

            ResultSetEntryBase rsentry = new ResultSetEntryBase(conn, rs, sql, columns,  extraValueNames);

            return rsentry;

        } catch (SQLException e) {

            JDBCUtils.closeQuietly(rs);

            JDBCUtils.closeQuietly(st);

            JDBCConnection.closeQuietly(conn);

            conn.closeQuietly();

            throw new JDBCExecutePreparedSQLException(sql, values, e);

        } finally {

            DisposeUtils.disposeQuietly(paramsDisposer);

        }

    }

    private List<ResultSetEntryBase> getResultSetValues() {

        synchronized(this.resulSets){

            List<ResultSetEntryBase> values = new ArrayList<>();

            values.addAll(this.resulSets.values());

            return values;

        }

    }

    @Override

    public synchronized void closeAll() {

        List<ResultSetEntryBase> values = getResultSetValues();

        for (ResultSetEntryBase entry : values) {

            JDBCUtils.closeQuietly(entry);

        }

    }

    @Override

    public synchronized void pack() {

        List<ResultSetEntryBase> values = getResultSetValues();

        int maxID = 0;

        for (ResultSetEntryBase entry : values) {

            if (entry.isZombie()) {

                JDBCUtils.closeQuietly(entry);

            } else {

                if (entry.getID() > maxID) {

                    maxID = entry.getID();

                }

            }

        }

        this.nextid = maxID + 1;

    }

    @Override

    public int getOpenCount() {

        synchronized(resulSets){

            return this.resulSets.size();

        }

    }

}