Application: gvSIG desktop

package org.gvsig.fmap.dal.store.jdbc2.spi.operations;

import java.sql.Connection;

import java.sql.DatabaseMetaData;

import java.sql.ResultSet;

import java.sql.ResultSetMetaData;

import java.sql.SQLException;

import java.sql.Statement;

import java.util.ArrayList;

import java.util.List;

import org.apache.commons.collections.CollectionUtils;

import org.apache.commons.lang3.StringUtils;

import org.cresques.cts.IProjection;

import org.gvsig.fmap.dal.DataTypes;

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

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

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

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

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

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

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryLocator;

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

public class FetchFeatureTypeOperation extends AbstractConnectionOperation {

    private final EditableFeatureType featureType;

    private final String dbname;

    private final String schema;

    private final String table;

    private final List<String> primaryKeys;

    private final String defaultGeometryColumn;

    private final IProjection crs;

    public FetchFeatureTypeOperation(

            JDBCHelper helper

        ) {

        this(helper, null, null, null, null, null, null, null);

    }

    public FetchFeatureTypeOperation(

            JDBCHelper helper,

            EditableFeatureType featureType,

            String dbname,

            String schema,

            String table,

            List<String> primaryKeys,

            String defaultGeometryColumn,

            IProjection crs

        ) {

        super(helper);

        this.featureType = featureType;

        this.dbname = dbname;

        this.schema = schema;

        this.table = table;

        this.primaryKeys = primaryKeys;

        this.defaultGeometryColumn = defaultGeometryColumn;

        this.crs = crs;

    }

    @Override

    public final Object perform(Connection conn) throws DataException {

        this.fetch(featureType, conn, dbname, schema, table, 

                primaryKeys, defaultGeometryColumn, crs

        );

        return true;

    }

    public void fetch(

            EditableFeatureType featureType,

            Connection conn,

            String database,

            String schema,

            String table,

            List<String> pks,

            String defaultGeometryColumn,

            IProjection crs

    ) throws DataException {

        Statement st = null;

        ResultSet rs = null;

        try {

            if (CollectionUtils.isEmpty(pks)) {

                if (!StringUtils.isEmpty(table)) {

                    pks = this.getPrimaryKeysFromMetadata(conn, null, schema, table);

                    if (CollectionUtils.isEmpty(pks)) {

                        pks = getPrimaryKeysFromInformationSchema(conn, null, schema, table);

                    }

                }

            }

            JDBCSQLBuilderBase sqlbuilder = this.createSQLBuilder();

            sqlbuilder.select().column().all();

            sqlbuilder.select().from().table().database(database).schema(schema).name(table);

            sqlbuilder.select().limit(1);

            st = conn.createStatement();

            st.setFetchSize(1);

            rs = JDBCUtils.executeQuery(st, sqlbuilder.toString());

            ResultSetMetaData rsMetadata = rs.getMetaData();

            int i;

            int geometriesColumns = 0;

            String lastGeometry = null;

            EditableFeatureAttributeDescriptor attr;

            boolean firstGeometryAttrFound = false;

            for (i = 1; i <= rsMetadata.getColumnCount(); i++) {

                attr = getAttributeFromMetadata(featureType, conn, rsMetadata, i);

                if (pks != null && pks.contains(attr.getName())) {

                    attr.setIsPrimaryKey(true);

                }

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

                    geometriesColumns++;

                    lastGeometry = attr.getName();

                    // Set the default geometry attribute if it is the one

                    // given as parameter or it is the first one, just in case.

                    if (!firstGeometryAttrFound || lastGeometry.equals(defaultGeometryColumn)) {

                        firstGeometryAttrFound = true;

                        featureType.setDefaultGeometryAttributeName(lastGeometry);

                    }

                }

            }

            if (geometriesColumns > 0) {

                fetch_CRS_and_shapeType(conn, rsMetadata, featureType, schema, table);

            }

            if (defaultGeometryColumn == null && geometriesColumns == 1) {

                featureType.setDefaultGeometryAttributeName(lastGeometry);

            }

        } catch (SQLException ex) {

            throw new RuntimeException("Can't fecth feature type.",ex);

        } finally {

            JDBCUtils.closeQuietly(rs);

            JDBCUtils.closeQuietly(st);

        }

        if (crs != null && featureType.getDefaultGeometryAttribute() != null) {

            ((EditableFeatureAttributeDescriptor) featureType.getDefaultGeometryAttribute()).setSRS(crs);

        }

    }

    protected List<String> getPrimaryKeysFromMetadata(

            Connection conn,

            String catalog,

            String schema,

            String table) throws SQLException {

        ResultSet rsPrimaryKeys = null;

        ResultSet rs = null;

        try {

            DatabaseMetaData metadata = conn.getMetaData();

            rs = metadata.getTables(catalog, schema, table, null);

            if (!rs.next()) {

                // No tables found with default values, ignoring catalog

                rs.close();

                catalog = null;

                schema = null;

                rs = metadata.getTables(catalog, schema, table, null);

                if (!rs.next()) {

                    // table not found

                    return null;

                } else if (rs.next()) {

                    // More that one, cant identify

                    return null;

                }

            } else if (rs.next()) {

                // More that one, cant identify

                return null;

            }

            rsPrimaryKeys = metadata.getPrimaryKeys(catalog, schema, table);

            List pks = new ArrayList();

            while (rsPrimaryKeys.next()) {

                pks.add(rsPrimaryKeys.getString("COLUMN_NAME"));

            }

            return pks;

        } catch (SQLException e) {

            return null;

        } finally {

            JDBCUtils.closeQuietly(rs);

            JDBCUtils.closeQuietly(rsPrimaryKeys);

        }

    }

    protected List<String> getPrimaryKeysFromInformationSchema(

            Connection conn,

            String catalog,

            String schema,

            String table) throws SQLException {

        JDBCSQLBuilderBase sqlbuilder = this.createSQLBuilder();

        sqlbuilder.select().column().name("COLUMN_NAME");

        sqlbuilder.select().column().name("CONSTRAINT_TYPE");

        sqlbuilder.select().from().custom(

                "INFORMATION_SCHEMA.table_constraints t_cons "

                + "inner join INFORMATION_SCHEMA.key_column_usage c on "

                + "c.constraint_catalog = t_cons.constraint_catalog and "

                + "c.table_schema = t_cons.table_schema and "

                + "c.table_name = t_cons.table_name and "

                + "c.constraint_name = t_cons.constraint_name "

        );

        sqlbuilder.select().where().set(

                sqlbuilder.like(

                        sqlbuilder.custom("c.TABLE_NAME"), // Con SQLServer si pones comillas no funciona.

                        sqlbuilder.constant(table)

                )

        );

        if (schema != null) {

            sqlbuilder.select().where().and(

                    sqlbuilder.like(

                            sqlbuilder.custom("c.TABLE_SCHEMA"),

                            sqlbuilder.constant(schema)

                    )

            );

        }

        if (catalog != null) {

            sqlbuilder.select().where().and(

                    sqlbuilder.like(

                            sqlbuilder.custom("c.CONSTRAINT_CATALOG"),

                            sqlbuilder.constant(catalog)

                    )

            );

        }

        sqlbuilder.select().where().and(

                sqlbuilder.eq(

                        sqlbuilder.column("CONSTRAINT_TYPE"),

                        sqlbuilder.constant("PRIMARY KEY")

                )

        );

        Statement st = null;

        ResultSet rs = null;

        List<String> pks = new ArrayList();

        try {

            st = conn.createStatement();

            rs = JDBCUtils.executeQuery(st, sqlbuilder.toString());

            while (rs.next()) {

                pks.add(rs.getString(1));

            }

            if (pks.isEmpty()) {

                return null;

            }

            return pks;

        } finally {

            JDBCUtils.closeQuietly(rs);

            JDBCUtils.closeQuietly(st);

        }

    }

    protected EditableFeatureAttributeDescriptor getAttributeFromMetadata(

            EditableFeatureType type,

            Connection conn,

            ResultSetMetaData rsMetadata,

            int colIndex

        ) throws SQLException {

        EditableFeatureAttributeDescriptor attr = type.add(

                rsMetadata.getColumnName(colIndex),

                this.getDataTypeFromMetadata(rsMetadata, colIndex)

        );

        attr.setAllowNull(

            rsMetadata.isNullable(colIndex) == ResultSetMetaData.columnNullable

        );

        attr.setIsAutomatic(rsMetadata.isAutoIncrement(colIndex));

        attr.setIsReadOnly(rsMetadata.isReadOnly(colIndex));

        attr.setPrecision(rsMetadata.getPrecision(colIndex));

        attr.setSize(rsMetadata.getColumnDisplaySize(colIndex));

        switch(attr.getType()) {

            case DataTypes.OBJECT:

                attr.setAdditionalInfo(

                        "SQLType",

                        rsMetadata.getColumnType(colIndex)

                );

                attr.setAdditionalInfo(

                        "SQLTypeName",

                        rsMetadata.getColumnTypeName(colIndex)

                );

                break;

            case DataTypes.GEOMETRY:

                this.fetchGeometryType(attr, rsMetadata, colIndex);

                break;

        }

        return attr;

    }

    protected void fetchGeometryType(

            EditableFeatureAttributeDescriptor attr,

            ResultSetMetaData rsMetadata,

            int colIndex

        ) {

        try {

            GeometryType geomType = GeometryLocator.getGeometryManager().getGeometryType(

                    Geometry.TYPES.GEOMETRY,

                    Geometry.SUBTYPES.GEOM2D

            );

            attr.setGeometryType(geomType);

        } catch (Exception ex) {

            logger.warn("Can't get default geometry type.",ex);

        }

    }

    protected int getDataTypeFromMetadata(

            ResultSetMetaData rsMetadata,

            int colIndex

        ) throws SQLException {

        switch (rsMetadata.getColumnType(colIndex)) {

            case java.sql.Types.INTEGER:

                return DataTypes.INT;

            case java.sql.Types.BIGINT:

                return DataTypes.LONG;

            case java.sql.Types.REAL:

                return DataTypes.DOUBLE;

            case java.sql.Types.DOUBLE:

                return DataTypes.DOUBLE;

            case java.sql.Types.CHAR:

                return DataTypes.STRING;

            case java.sql.Types.VARCHAR:

            case java.sql.Types.LONGVARCHAR:

                return DataTypes.STRING;

            case java.sql.Types.FLOAT:

                return DataTypes.DOUBLE;

            case java.sql.Types.NUMERIC:

                return DataTypes.DOUBLE;

            case java.sql.Types.DECIMAL:

                return DataTypes.FLOAT;

            case java.sql.Types.DATE:

                return DataTypes.DATE;

            case java.sql.Types.TIME:

                return DataTypes.TIME;

            case java.sql.Types.TIMESTAMP:

                return DataTypes.TIMESTAMP;

            case java.sql.Types.BOOLEAN:

            case java.sql.Types.BIT:

                return DataTypes.BOOLEAN;

            case java.sql.Types.BLOB:

            case java.sql.Types.BINARY:

            case java.sql.Types.LONGVARBINARY:

                return DataTypes.BYTEARRAY;

            default:

                String typeName = rsMetadata.getColumnTypeName(colIndex);

                if( "geometry".equalsIgnoreCase(typeName) ) {

                    return DataTypes.GEOMETRY;

                }

                return DataTypes.OBJECT;

        }

    }

    protected void fetch_CRS_and_shapeType(

            Connection conn,

            ResultSetMetaData rsMetadata,

            EditableFeatureType featureType,

            String schema,

            String table

        ) throws SQLException {

        // Nothing to do

    }

}