Application: gvSIG desktop » gvSIG data provider for PostgreSQL

package org.gvsig.postgresql.dal;

import java.sql.Connection;

import java.sql.PreparedStatement;

import java.sql.SQLException;

import java.util.ArrayList;

import java.util.List;

import org.apache.commons.dbcp.BasicDataSource;

import org.apache.commons.dbcp.BasicDataSourceFactory;

import org.apache.commons.lang3.BooleanUtils;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.fmap.dal.DataTypes;

import org.gvsig.fmap.dal.ExpressionBuilder;

import org.gvsig.fmap.dal.SQLBuilder;

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

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

import org.gvsig.fmap.dal.feature.spi.FeatureProvider;

import org.gvsig.fmap.dal.resource.exception.AccessResourceException;

import org.gvsig.fmap.dal.store.jdbc.JDBCConnectionParameters;

import org.gvsig.fmap.dal.store.jdbc.JDBCNewStoreParameters;

import org.gvsig.fmap.dal.store.jdbc.JDBCServerExplorerParameters;

import org.gvsig.fmap.dal.store.jdbc.JDBCStoreParameters;

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

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

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

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

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

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

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.aggregate.MultiLine;

import org.gvsig.fmap.geom.aggregate.MultiPoint;

import org.gvsig.fmap.geom.aggregate.MultiPolygon;

import org.gvsig.fmap.geom.exception.CreateGeometryException;

import org.gvsig.fmap.geom.primitive.Primitive;

import org.gvsig.fmap.geom.type.GeometryType;

import org.gvsig.postgresql.dal.operations.PostgreSQLOperationsFactory;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class PostgreSQLHelper extends JDBCHelperBase {

    static final Logger logger = LoggerFactory.getLogger(PostgreSQLHelper.class);

    public static final String POSTGRESQL_JDBC_DRIVER = "org.postgresql.Driver";

    public static String getConnectionURL(PostgreSQLConnectionParameters params) {

        return getConnectionURL(

            params.getHost(),

            params.getPort(),

            params.getDBName()

        );

    }

    public static String getConnectionURL(String host, Integer port, String db) {

        if( StringUtils.isEmpty(host) ) {

            throw new IllegalArgumentException("Parameter 'host' can't be null.");

        }

        String connectionURL = "jdbc:postgresql://" + host;

        if (port != null) {

            connectionURL = connectionURL + ":" + port;

        }

        connectionURL = connectionURL + "/" + db;

        logger.debug("connectionURL: {}", connectionURL);

        return connectionURL;

    }

    private static class ConnectionProvider {

        private static boolean needRegisterDriver = true;

        private BasicDataSource dataSource = null;

        private final PostgreSQLConnectionParameters connectionParameters;

        public ConnectionProvider(PostgreSQLConnectionParameters connectionParameters) {

            this.connectionParameters = connectionParameters;

        }

        public Connection getConnection() throws SQLException {

            if (this.dataSource == null) {

                this.dataSource = this.createDataSource();               

            }

            if( logger.isDebugEnabled() ) {

                logger.debug("getConnection:\n" + getStatusInformation());

            }

            Connection conn;

            try {

                conn = this.dataSource.getConnection();

            } catch(Throwable ex) {

                logger.debug("Error getting connection from pool.",ex);

                throw ex;

            }

            if( logger.isDebugEnabled() ) {

                logger.debug("Created connection: {}\n  NumActive: {}\n  NumIdle: {}",

                    new Object[] {

                        conn.hashCode(), 

                        this.dataSource.getNumActive(),

                        this.dataSource.getNumIdle()

                    }

                );

            }

            return conn;

        }

        public void closeConnection(Connection connection) {

            if( connection != null ) {

                int connectionId = connection.hashCode();

                try {

                    connection.close();

                } catch(Throwable ex) {

                    logger.warn("Can't close connection.", ex);

                }

                if( logger.isDebugEnabled() ) {

                    Boolean isClosed;

                    try {

                        isClosed = connection.isClosed();

                    } catch(Throwable th) {

                        isClosed = null;

                    }

                    logger.debug("Closed connection: {}\n  isClosed: {}\n  NumActive: {}\n  NumIdle: {}",

                        new Object[] {

                            connectionId, 

                            isClosed,

                            this.dataSource.getNumActive(),

                            this.dataSource.getNumIdle()

                        }

                    );

                }

           } else if( logger.isDebugEnabled() ) {

               logger.debug("Close connection: null");

           }

        }

        public String getStatusInformation() {

            StringBuilder builder = new StringBuilder();

            builder.append("BasicDataSource pool status:\n");

            builder.append("  Connection URL: '").append(this.dataSource.getUrl()).append("'\n");

            if( this.dataSource.getInitialSize()>0 ) {

                builder.append("  InitialSize: ").append(this.dataSource.getInitialSize()).append(" (The initial number of connections that are created when the pool is started)\n");

            }

            if( this.dataSource.isPoolPreparedStatements() ) {

                builder.append("  PoolPreparedStatements: ").append(this.dataSource.isPoolPreparedStatements()).append("\n");

                builder.append("  MaxOpenPreparedStatements: ").append(this.dataSource.getMaxOpenPreparedStatements()).append(" (The maximum number of open statements that can be allocated from the statement pool at the same time, or non-positive for no limit)\n");

            }

            builder.append("  MaxActive: ").append(this.dataSource.getMaxActive()).append(" (The maximum number of active connections that can be allocated from this pool at the same time)\n");

            builder.append("  MaxIdle: ").append(this.dataSource.getMaxIdle()).append(" (The maximum number of connections that can remain idle in the pool)\n");

            builder.append("  NumActive:").append(this.dataSource.getNumActive()).append(" (the current number of active connections)\n");

            builder.append("  NumIdle:").append(this.dataSource.getNumIdle()).append(" (the current number of idle connections)\n");

            return builder.toString();

        }

        private BasicDataSource createDataSource() throws SQLException {

            if (!this.isRegistered()) {

                this.registerDriver();

            }

            PostgreSQLConnectionParameters params = connectionParameters;

            BasicDataSource ds = new BasicDataSource();

            ds.setMaxIdle(params.getMaxIdle());

            ds.setDriverClassName(params.getJDBCDriverClassName());

            if( params.getUseSSL() ) {

                String s = BooleanUtils.toStringTrueFalse(params.getUseSSL());

                ds.addConnectionProperty("ssl", s );

            }

            if( !StringUtils.isEmpty(params.getUser()) ) {

                ds.setUsername(params.getUser());

            }

            if( !StringUtils.isEmpty(params.getPassword()) ) {

                ds.setPassword(params.getPassword());

            }

            ds.setUrl(params.getUrl());

            ds.setMaxWait(60L * 1000);

            return ds;

        }

        private boolean isRegistered() {

            return needRegisterDriver;

        }

        public void registerDriver() throws SQLException {

            String className = this.connectionParameters.getJDBCDriverClassName();

            if (className == null) {

                return;

            }

            try {

                Class theClass = Class.forName(className);

                if (theClass == null) {

                    throw new JDBCDriverClassNotFoundException(PostgreSQLLibrary.NAME, className);

                }

            } catch (Exception e) {

                throw new SQLException("Can't register JDBC driver '" + className + "'.", e);

            }

            needRegisterDriver = false;

        }

    }

    private ConnectionProvider connectionProvider = null;

    public PostgreSQLHelper(JDBCConnectionParameters connectionParameters) {

        super(connectionParameters);

        this.srssolver = new SRSSolverBase(this);

    }

    @Override

    public Connection getConnection() throws AccessResourceException {

        try {

            if (this.connectionProvider == null) {

                this.connectionProvider = new ConnectionProvider(this.getConnectionParameters());

            }

            return this.connectionProvider.getConnection();

        } catch (SQLException ex) {

            throw new AccessResourceException(PostgreSQLLibrary.NAME, ex);

        }

    }

    @Override

    public void closeConnection(Connection connection) {

         this.connectionProvider.closeConnection(connection);

    }

    @Override

    public PostgreSQLConnectionParameters getConnectionParameters() {

        return (PostgreSQLConnectionParameters) super.getConnectionParameters();

    }

    @Override

    public String getConnectionURL() {

        return getConnectionURL(this.getConnectionParameters());

    }

    @Override

    protected String getResourceType() {

        return PostgreSQLLibrary.NAME;

    }

    @Override

    public String getProviderName() {

        return PostgreSQLLibrary.NAME;

    }

    @Override

    public JDBCSQLBuilderBase createSQLBuilder() {

        return new PostgreSQLBuilder(this);

    }

    @Override

    public OperationsFactory getOperations() {

        if (this.operationsFactory == null) {

            this.operationsFactory = new PostgreSQLOperationsFactory(this);

        }

        return operationsFactory;

    }

    @Override

    public SQLBuilder.GeometrySupportType getGeometrySupportType() {

        return SQLBuilder.GeometrySupportType.WKB;

    }

    @Override

    public boolean hasSpatialFunctions() {

        return true;

    }

    @Override

    public boolean canWriteGeometry(int geometryType, int geometrySubtype) {

        return true;

    }

    @Override

    public String getQuoteForIdentifiers() {

        return "\"";

    }

    @Override

    public boolean allowAutomaticValues() {

        return true;

    }

    @Override

    public boolean supportOffsetInSelect() {

        return true;

    }

    @Override

    public String getQuoteForStrings() {

        return "'";

    }

    @Override

    public String getSourceId(JDBCStoreParameters parameters) {

        return parameters.getDBName() + "." + 

               parameters.getSchema()+ "." + 

               parameters.getTable();

    }

    @Override

    public JDBCNewStoreParameters createNewStoreParameters() {

        return new PostgreSQLNewStoreParameters();

    }

    @Override

    public JDBCStoreParameters createOpenStoreParameters() {

        return new PostgreSQLStoreParameters();

    }

    @Override

    public JDBCServerExplorerParameters createServerExplorerParameters() {

        return new PostgreSQLServerExplorerParameters();

    }

    public void setPreparedStatementParameters(PreparedStatement st, JDBCSQLBuilderBase sqlbuilder, FeatureType type, FeatureProvider feature) {

        try {

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

            for (ExpressionBuilder.Parameter parameter : sqlbuilder.getParameters()) {

                Object value;

                if (parameter.is_constant()) {

                    value = parameter.getValue();

                } else {

                    String name = parameter.getName();

                    value = feature.get(name);

                    FeatureAttributeDescriptor attr = type.getAttributeDescriptor(name);

                    if( attr.getType()==DataTypes.GEOMETRY ) {

                        value = forceGeometry(attr.getGeomType(), (Geometry) value);

                    }

                }

                values.add(value);

            }

            JDBCUtils.setObjects(st, values, sqlbuilder.geometry_support_type());

        } catch (Exception ex) {

            String f = "unknow";

            try {

                f = feature.toString();

            } catch (Exception ex2) {

                // Do nothing

            }

            throw new RuntimeException("Can't set parameters to prepared statement from the feature (" + f + ")", ex);

        }

    }

    private Geometry forceGeometry(GeometryType geomtype, Geometry geom) throws CreateGeometryException {

        if( geom == null ) {

            return null;

        }

        switch( geomtype.getType() ) {

        case Geometry.TYPES.MULTIPOLYGON:

            if( geom.getType()==Geometry.TYPES.POLYGON ) {

                MultiPolygon x = getGeometryManager().createMultiPolygon(geomtype.getSubType());

                x.addPrimitive((Primitive) geom);

                geom = x;

            }

            break;

        case Geometry.TYPES.MULTILINE:

            if( geom.getType()==Geometry.TYPES.LINE ) {

                MultiLine x = getGeometryManager().createMultiLine(geomtype.getSubType());

                x.addPrimitive((Primitive) geom);

                geom = x;

            }

            break;

        case Geometry.TYPES.MULTIPOINT:

            if( geom.getType()==Geometry.TYPES.POINT ) {

                MultiLine x = getGeometryManager().createMultiLine(geomtype.getSubType());

                x.addPrimitive((Primitive) geom);

                geom = x;

            }

            break;

        case Geometry.TYPES.POLYGON:

            if( geom.getType()==Geometry.TYPES.MULTIPOLYGON ) {

                MultiPolygon x = (MultiPolygon) geom;

                if( x.getPrimitivesNumber()==1 ) {

                    geom = x.getPrimitiveAt(0);

                }

            }

            break;

        case Geometry.TYPES.LINE:

            if( geom.getType()==Geometry.TYPES.MULTILINE ) {

                MultiLine x = (MultiLine) geom;

                if( x.getPrimitivesNumber()==1 ) {

                    geom = x.getPrimitiveAt(0);

                }

            }

            break;

        case Geometry.TYPES.POINT:

            if( geom.getType()==Geometry.TYPES.MULTIPOINT ) {

                MultiPoint x = (MultiPoint) geom;

                if( x.getPrimitivesNumber()==1 ) {

                    geom = x.getPrimitiveAt(0);

                }

            }

        }

        return geom;

    }

}