Application: gvSIG desktop

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

import java.sql.Connection;

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.store.jdbc.exception.JDBCExecutePreparedSQLException;

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.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 String sql;

        public ResultSetEntryBase(ResultSet resulSet) {

            this(resulSet,null);

        }

        public ResultSetEntryBase(ResultSet resulSet, String sql) {

            this.resultSet = resulSet;

            this.id = nextid++;

            this.sql = sql;

            used();

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

        }

        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 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 {

            return this.resultSet.next();

        }

        @Override

        public void close() throws Exception {

            if( this.resultSet == null ) {

                // Already close

                return;

            }

            Statement st = null;

            Connection con = null;

            try {

                resulSets.remove(this.getID());

                st = this.resultSet.getStatement();

                if( st != null ) {

                    con = st.getConnection();

                }

            } catch(Exception ex) {

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

            }

            JDBCUtils.closeQuietly(this.resultSet);

            JDBCUtils.closeQuietly(st);

            JDBCUtils.closeQuietly(con);

            this.resultSet = null;

            logger.debug(

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

                    this.getID(),

                    getOpenCount()

            );

            pack();

        }

    }

    private int nextid = 1;

    private 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 = null;

        this.nextid = -10;

    }

    @Override

    public ResultSetEntryBase create(String sql, int fetchSize) throws DataException {

        return create(sql, null, fetchSize);

    }

    @Override

    public synchronized ResultSetEntryBase create(

            final String sql,

            final List values,

            final int fetchSize) throws DataException {

        this.pack();

        ResultSet rs = null;

        Connection conn = null;

        PreparedStatement st = null;

        try {

            conn = helper.getConnection();

            conn.setAutoCommit(false);

            st = conn.prepareStatement(sql);

            JDBCUtils.setObjects(st, values, helper.getGeometrySupportType());

            if (fetchSize > 0) {

                st.setFetchSize(fetchSize);

            }

            rs = JDBCUtils.executeQuery(st, sql);

            if (fetchSize > 0) {

                rs.setFetchSize(fetchSize);

            }

        } catch (SQLException e) {

            JDBCUtils.closeQuietly(rs);

            JDBCUtils.closeQuietly(st);

            JDBCUtils.closeQuietly(conn);

            throw new JDBCExecutePreparedSQLException(sql, values, e);

        }

        ResultSetEntryBase rsentry = new ResultSetEntryBase(rs, sql);

        return rsentry;

    }

    @Override

    public synchronized void closeAll() {

        // Para evitar problemas de concurrencia al eliminar elementos del

        // map mientras lo recorremos, cargamos las entredas en un List

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

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

        for (ResultSetEntryBase entry : entries) {

            JDBCUtils.closeQuietly(entry);

        }

    }

    @Override

    public synchronized void pack() {

        // Para evitar problemas de concurrencia al eliminar elementos del

        // map mientras lo recorremos, cargamos las entredas en un List

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

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

        int maxID = 0;

        for (ResultSetEntryBase entry : entries) {

            if (entry.isZombie()) {

                JDBCUtils.closeQuietly(entry);

            } else {

                if (entry.getID() > maxID) {

                    maxID = entry.getID();

                }

            }

        }

        this.nextid = maxID + 1;

    }

    @Override

    public synchronized int getOpenCount() {

        return this.resulSets.size();

    }

}