| gvSIG desktop 1

/* gvSIG. Geographic Information System of the Valencian Government

 *

 * Copyright (C) 2007-2008 Infrastructures and Transports Department

 * of the Valencian Government (CIT)

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 */

/*

 * AUTHORS (In addition to CIT):

 * 2009 Prodevelop S.L. main development

 */

package org.gvsig.fmap.dal.store.oracle;

import java.awt.geom.Rectangle2D;

import java.sql.Connection;

import java.sql.ResultSet;

import java.sql.ResultSetMetaData;

import java.sql.SQLException;

import java.sql.Statement;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Iterator;

import java.util.List;

import oracle.sql.ARRAY;

import oracle.sql.Datum;

import oracle.sql.STRUCT;

import org.cresques.cts.IProjection;

import org.gvsig.fmap.crs.CRSFactory;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataTypes;

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

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

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

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

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

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

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

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

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

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

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

import org.gvsig.fmap.dal.feature.exception.UnsupportedDataTypeException;

import org.gvsig.fmap.dal.feature.exception.UnsupportedGeometryException;

import org.gvsig.fmap.dal.feature.impl.DefaultEditableFeatureAttributeDescriptor;

import org.gvsig.fmap.dal.feature.impl.DefaultEditableFeatureType;

import org.gvsig.fmap.dal.feature.impl.DefaultFeatureType;

import org.gvsig.fmap.dal.resource.spi.ResourceManagerProviderServices;

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

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

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

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

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

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

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.Geometry.SUBTYPES;

import org.gvsig.fmap.geom.Geometry.TYPES;

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

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

import org.gvsig.fmap.geom.primitive.impl.Envelope2D;

import org.gvsig.fmap.geom.primitive.impl.Envelope3D;

import org.gvsig.fmap.geom.primitive.impl.Point2DZ;

import org.gvsig.tools.exception.BaseException;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * Oracle helper

 * 

 * @author vsanjaime

 * 

 */

public class OracleHelper extends JDBCHelper {

        private static final double ORACLE_SPATIAL_DEFAULT_TOLERANCE = 0.0005;

        private static final String IDENTIFIER_QUOTE_STRING = "\"";

        private static Logger logger = LoggerFactory.getLogger(OracleHelper.class);

        private boolean tableHasSrid = true;

        private String oracleSRID;

        /**

         * Constructor

         * 

         * @param consumer

         * @param params

         * @throws InitializeException

         */

        public OracleHelper(JDBCHelperUser consumer,

                        OracleConnectionParameters params) throws InitializeException {

                super(consumer, params);

        }

        /**

         * Initialize resource

         * 

         * @throws InitializeException

         */

        protected void initializeResource() throws InitializeException {

                ResourceManagerProviderServices manager = (ResourceManagerProviderServices) DALLocator

                                .getResourceManager();

                OracleResource resource = (OracleResource) manager.createResource(

                                OracleResource.NAME, new Object[] {

                                                params.getUrl(),

                                                params.getHost(),

                                                params.getPort(),

                                                params.getDBName(),

                                                params.getUser(),

                                                params.getPassword(),

                                                params.getJDBCDriverClassName(),

                                                ((OracleConnectionParameters) params).getUseSSL(),

                                                ((OracleConnectionParameters) params)

                                                                .getOraDriverType() });

                this.setResource(resource);

        }

        /**

         * Get default schema name

         * 

         * @param conn

         * @return

         */

        protected String getDefaultSchema(Connection conn) throws JDBCException {

                if (defaultSchema == null) {

                        String sql = "SELECT sys_context('USERENV', 'CURRENT_SCHEMA') FROM dual";

                        ResultSet rs = null;

                        Statement st = null;

                        String schema = null;

                        try {

                                st = conn.createStatement();

                                try {

                                        rs = st.executeQuery(sql);

                                } catch (java.sql.SQLException e) {

                                        throw new JDBCExecuteSQLException(sql, e);

                                }

                                rs.next();

                                schema = rs.getString(1);

                        } catch (java.sql.SQLException e) {

                                throw new JDBCSQLException(e);

                        } finally {

                                try {

                                        rs.close();

                                } catch (Exception e) {

                                        logger.error("Exception clossing resulset", e);

                                }

                                ;

                                try {

                                        st.close();

                                } catch (Exception e) {

                                        logger.error("Exception clossing statement", e);

                                }

                                ;

                                rs = null;

                                st = null;

                        }

                        defaultSchema = schema;

                }

                return defaultSchema;

        }

        /**

         * get full envelope of geometry field

         */

        public Envelope getFullEnvelopeOfField(JDBCStoreParameters storeParams,

                        String geometryAttrName, Envelope limit) throws DataException {

                StringBuilder strb = new StringBuilder();

                strb.append("SELECT * FROM "

                                + OracleValues.USER_ORACLE_GEOMETADATA_VIEW);

                strb.append(" WHERE "

                                + OracleValues.USER_ORACLE_GEOMETADATA_VIEW_TABLE_NAME

                                + " = '" + storeParams.getTable() + "'");

                strb.append(" AND "

                                + OracleValues.USER_ORACLE_GEOMETADATA_VIEW_COLUMN_NAME

                                + " = '" + geometryAttrName + "'");

                String sql = strb.toString();

                ResultSet rs = null;

                Statement st = null;

                String schema = null;

                Connection conn = null;

                Envelope fullEnvelope = null;

                this.open();

                try {

                        conn = getConnection();

                        st = conn.createStatement();

                        try {

                                rs = st.executeQuery(sql);

                        } catch (java.sql.SQLException e) {

                                throw new JDBCExecuteSQLException(sql, e);

                        }

                        if (!rs.next()) {

                                return null;

                        }

                        // DIMINFO (ARRAY)

                        ARRAY dim_info_array = (ARRAY) rs.getObject("DIMINFO");

                        Datum[] da = dim_info_array.getOracleArray();

                        int dim = da.length;

                        STRUCT sx = (STRUCT) da[0];

                        STRUCT sy = (STRUCT) da[1];

                        double minx = Double.parseDouble(sx.getAttributes()[1].toString());

                        double maxx = Double.parseDouble(sx.getAttributes()[2].toString());

                        double miny = Double.parseDouble(sy.getAttributes()[1].toString());

                        double maxy = Double.parseDouble(sy.getAttributes()[2].toString());

                        if (minx > maxx) {

                                double aux = minx;

                                minx = maxx;

                                maxx = aux;

                        }

                        if (miny > maxy) {

                                double aux = miny;

                                miny = maxy;

                                maxy = aux;

                        }

                        // dim 3

                        STRUCT sz = null;

                        double minz = 0;

                        double maxz = 0;

                        if (dim == 2) {

                                fullEnvelope = new Envelope2D(minx, miny, maxx, maxy);

                        } else if (dim == 3) {

                                sz = (STRUCT) da[2];

                                minz = Double.parseDouble(sz.getAttributes()[1].toString());

                                maxz = Double.parseDouble(sz.getAttributes()[2].toString());

                                Point minPto = new Point2DZ(minx, miny, minz);

                                Point maxPto = new Point2DZ(maxx, maxy, maxz);

                                fullEnvelope = new Envelope3D(minPto, maxPto);

                        }

                        return fullEnvelope;

                } catch (Exception e) {

                        return null;

                }

                finally {

                        try {

                                rs.close();

                        } catch (Exception e) {

                        }

                        try {

                                st.close();

                        } catch (Exception e) {

                        }

                        try {

                                conn.close();

                        } catch (Exception e) {

                        }

                        finally {

                                rs = null;

                                st = null;

                                conn = null;

                        }

                }

        }

        /**

         * 

         */

//        protected void initializeFromWKBOperation() throws BaseException {

//                // TODO

//                if (fromWKB == null) {

//                        fromWKB = (FromWKB) GeometryLocator.getGeometryManager()

//                                        .getGeometryOperation(FromWKB.CODE,

//                                                        Geometry.TYPES.GEOMETRY, Geometry.SUBTYPES.GEOM2D);

//                        fromWKBContext = new FromWKBGeometryOperationContext();

//                }

//        }

        /**

         * 

         */

        public Geometry getGeometry(byte[] buffer) throws BaseException {

                // TODO BLOB format in Oracle?

                logger.error("Unsupported: binary Geometry format");

                return null;

        }

        /**

         * get geometry column name "SDO_GEOMETRY"

         * 

         * @param attr

         * @return

         */

        public String getSqlColumnTypeDescription(FeatureAttributeDescriptor attr) {

                switch (attr.getDataType()) {

                case DataTypes.GEOMETRY:

                        return "\"MDSYS\".\"SDO_GEOMETRY\"";

                case DataTypes.STRING:

                        return "NVARCHAR2(" + attr.getSize() + ")";

                case DataTypes.BOOLEAN:

                        return "NUMBER(1, 0)";

                case DataTypes.BYTE:

                        return "NUMBER";

                case DataTypes.DATE:

                        return "DATE";

                case DataTypes.TIMESTAMP:

                        return "TIMESTAMP";

                case DataTypes.TIME:

                        return "TIMESTAMP";

                case DataTypes.BYTEARRAY:

                case DataTypes.DOUBLE:

                        return "FLOAT";

                case DataTypes.FLOAT:

                        return "FLOAT";

                case DataTypes.INT:

                        return "NUMBER(12, 0)";

                case DataTypes.LONG:

                        return "NUMBER(38, 0)";

                default:

                        String typeName = (String) attr.getAdditionalInfo("SQLTypeName");

                        if (typeName != null) {

                                return typeName;

                        }

                        throw new UnsupportedDataTypeException(attr.getDataTypeName(), attr

                                        .getDataType());

                }

        }

        /**

         * Get oracle geometry dimension

         * 

         * @param geometrySubType

         * @return

         */

        public int getOraGeomDimensions(int geometrySubType) {

                switch (geometrySubType) {

                case Geometry.SUBTYPES.GEOM2D:

                        return 2;

                case Geometry.SUBTYPES.GEOM2DM:

                case Geometry.SUBTYPES.GEOM3D:

                        return 3;

                case Geometry.SUBTYPES.GEOM3DM:

                        return 4;

                default:

                        throw new UnsupportedDataTypeException(

                                        DataTypes.TYPE_NAMES[DataTypes.GEOMETRY],

                                        DataTypes.GEOMETRY);

                }

        }

        /**

         * Get Oracle geometry type

         * 

         * @param geometryType

         * @param geometrySubType

         * @return

         */

        public String getOraGeomType(int geometryType, int geometrySubType) {

                String oraGeomType;

                switch (geometryType) {

                case Geometry.TYPES.GEOMETRY:

                        oraGeomType = OracleValues.OraGeometry_GTYPE_GEOMETRY;

                        break;

                case Geometry.TYPES.POINT:

                        oraGeomType = OracleValues.OraGeometry_GTYPE_POINT;

                        break;

                case Geometry.TYPES.CURVE:

                        oraGeomType = OracleValues.OraGeometry_GTYPE_CURVE;

                        break;

                case Geometry.TYPES.TEXT:

                        oraGeomType = OracleValues.OraGeometry_GTYPE_GEOMETRY;

                        break;

                case Geometry.TYPES.SOLID:

                        oraGeomType = OracleValues.OraGeometry_GTYPE_GEOMETRY;

                        break;

                case Geometry.TYPES.AGGREGATE:

                        oraGeomType = OracleValues.OraGeometry_GTYPE_GEOMETRY;

                        break;

                case Geometry.TYPES.SURFACE:

                        oraGeomType = OracleValues.OraGeometry_GTYPE_POLYGON;

                        break;

                case Geometry.TYPES.MULTIPOINT:

                        oraGeomType = OracleValues.OraGeometry_GTYPE_MULTIPOINT;

                        break;

                case Geometry.TYPES.MULTICURVE:

                        oraGeomType = OracleValues.OraGeometry_GTYPE_MULTICURVE;

                        break;

                case Geometry.TYPES.MULTISURFACE:

                        oraGeomType = OracleValues.OraGeometry_GTYPE_MULTIPOLYGON;

                        break;

                case Geometry.TYPES.MULTISOLID:

                        oraGeomType = OracleValues.OraGeometry_GTYPE_GEOMETRY;

                        break;

                case Geometry.TYPES.CIRCLE:

                        oraGeomType = OracleValues.OraGeometry_GTYPE_GEOMETRY;

                        break;

                case Geometry.TYPES.ARC:

                        oraGeomType = OracleValues.OraGeometry_GTYPE_GEOMETRY;

                        break;

                case Geometry.TYPES.ELLIPSE:

                        oraGeomType = OracleValues.OraGeometry_GTYPE_GEOMETRY;

                        break;

                case Geometry.TYPES.SPLINE:

                        oraGeomType = OracleValues.OraGeometry_GTYPE_GEOMETRY;

                        break;

                case Geometry.TYPES.ELLIPTICARC:

                        oraGeomType = OracleValues.OraGeometry_GTYPE_GEOMETRY;

                        break;

                default:

                        throw new UnsupportedGeometryException(geometryType,

                                        geometrySubType);

                }

                return oraGeomType;

        }

        /**

         * 

         */

        public String getSqlFieldName(FeatureAttributeDescriptor attribute) {

                /*

                if (attribute.getDataType() == DataTypes.GEOMETRY) {

                        return "asBinary(" + super.getSqlFieldName(attribute) + ")";

                }

                */

                return super.getSqlFieldName(attribute);

        }

        protected String getIdentifierQuoteString() {

                return IDENTIFIER_QUOTE_STRING;

        }

        /**

         * 

         */

        protected EditableFeatureAttributeDescriptor createAttributeFromJDBC(

                        EditableFeatureType fType, Connection conn,

                        ResultSetMetaData rsMetadata, int colIndex) throws SQLException {

                String rstypename = rsMetadata.getColumnTypeName(colIndex);

                if (rstypename

                                .equalsIgnoreCase(OracleValues.OraGeometry_GTYPE_GEOMETRY)) {

                        return fType.add(rsMetadata.getColumnName(colIndex),

                                        DataTypes.GEOMETRY);

                }

                EditableFeatureAttributeDescriptor column;

                switch (rsMetadata.getColumnType(colIndex)) {

                case java.sql.Types.INTEGER:

                        column = fType.add(rsMetadata.getColumnName(colIndex),

                                        DataTypes.INT);

                        break;

                case java.sql.Types.BIGINT:

                        column = fType.add(rsMetadata.getColumnName(colIndex),

                                        DataTypes.LONG);

                        break;

                case java.sql.Types.REAL:

                        column = fType.add(rsMetadata.getColumnName(colIndex),

                                        DataTypes.DOUBLE);

                        break;

                case java.sql.Types.DOUBLE:

                        column = fType.add(rsMetadata.getColumnName(colIndex),

                                        DataTypes.DOUBLE);

                        break;

                case java.sql.Types.CHAR:

                        column = fType.add(rsMetadata.getColumnName(colIndex),

                                        DataTypes.STRING);

                        break;

                case java.sql.Types.VARCHAR:

                case java.sql.Types.LONGVARCHAR:

                        column = fType.add(rsMetadata.getColumnName(colIndex),

                                        DataTypes.STRING);

                        break;

                case java.sql.Types.FLOAT:

                        column = fType.add(rsMetadata.getColumnName(colIndex),

                                        DataTypes.FLOAT);

                        break;

                case java.sql.Types.DECIMAL:

                        column = fType.add(rsMetadata.getColumnName(colIndex),

                                        DataTypes.FLOAT);

                        break;

                case java.sql.Types.DATE:

                        column = fType.add(rsMetadata.getColumnName(colIndex),

                                        DataTypes.DATE);

                        break;

                case java.sql.Types.TIME:

                        column = fType.add(rsMetadata.getColumnName(colIndex),

                                        DataTypes.TIME);

                        break;

                case java.sql.Types.TIMESTAMP:

                        column = fType.add(rsMetadata.getColumnName(colIndex),

                                        DataTypes.TIMESTAMP);

                        break;

                case java.sql.Types.BOOLEAN:

                        column = fType.add(rsMetadata.getColumnName(colIndex),

                                        DataTypes.BOOLEAN);

                        break;

                case java.sql.Types.BLOB:

                case java.sql.Types.BINARY:

                case java.sql.Types.LONGVARBINARY:

                        column = fType.add(rsMetadata.getColumnName(colIndex),

                                        DataTypes.BYTEARRAY);

                        break;

                case java.sql.Types.NUMERIC:

                        // decimal positions to the right of point

                        int scale = rsMetadata.getScale(colIndex);

                        // decimal positions to the right of point

                        // int leftdigits = rsMetadata.getPrecision(colIndex);

                        if (scale == 0) { 

                                column = fType.add(rsMetadata.getColumnName(colIndex),

                                                DataTypes.LONG);

                        } else {

                                column = fType.add(rsMetadata.getColumnName(colIndex),

                                                DataTypes.DOUBLE);

                        }

                        break;

                default:

                        column = fType.add(rsMetadata.getColumnName(colIndex),

                                        DataTypes.OBJECT);

                        column.setAdditionalInfo("SQLType", new Integer(rsMetadata

                                        .getColumnType(colIndex)));

                        column.setAdditionalInfo("SQLTypeName", rsMetadata

                                        .getColumnTypeName(colIndex));

                        break;

                }

                return column;

                // return super.createAttributeFromJDBC(type, conn, rsMetadata, colIndex);

        }

        /**

         * 

         */

        public boolean allowAutomaticValues() {

                return Boolean.TRUE;

        }

        /**

         * 

         */

        public boolean supportOffset() {

                return true;

        }

        /**

         * 

         */

        public boolean supportsUnion() {

                return true;

        }

        /**

         * get sql with fields description

         * 

         * @param attr

         * @return

         */

        public String getSqlFieldDescription(FeatureAttributeDescriptor attr)

                        throws DataException {

                StringBuilder strb = new StringBuilder();

                // name

                strb.append("\"" + attr.getName() + "\" ");

                // Type

                strb.append(this.getSqlColumnTypeDescription(attr));

                // Primary key

                if (attr.isPrimaryKey()) {

                        strb.append(" PRIMARY KEY");

                }

                return strb.toString();

        }

        /**

         * UTility method to get the SQL sentence needed to update the geographic

         * metadata table with a new bounding box and SRS

         * 

         * @param tName

         *            table name

         * @param ora_srid

         *            new SRS

         * @param bbox

         *            new bounding box

         * @param dim

         *            geometries dimension

         * @param withsrid

         *            False if the SRS is set to NULL. True otherwise.

         * @return the SQL sentence to perform the update

         */

        public String getSqlUpdateMetadata(OracleStoreParameters params,

                        String ora_srid, Rectangle2D bbox, int dim, boolean withsrid) {

                String[] dim_name = new String[dim];

                // double tolerance = ORACLE_SPATIAL_DEFAULT_TOLERANCE;

                String _ora_srid = ora_srid;

                if (_ora_srid == null)

                        _ora_srid = "NULL";

                if (_ora_srid.compareTo(OracleValues.GEODETIC_SRID) == 0) {

                        dim_name[0] = "LONGITUDE";

                        dim_name[1] = "LATITUDE";

                } else {

                        dim_name[0] = "X";

                        dim_name[1] = "Y";

                        if (dim > 2) {

                                dim_name[2] = "Z";

                                if (dim > 3) {

                                        dim_name[3] = "T";

                                }

                        }

                }

                double minx = bbox.getMinX();

                double miny = bbox.getMinY();

                double maxx = bbox.getMaxX();

                double maxy = bbox.getMaxY();

                String resp = "INSERT INTO "

                                + OracleValues.USER_ORACLE_GEOMETADATA_VIEW + " "

                                + " ( TABLE_NAME, COLUMN_NAME, DIMINFO, SRID ) " + " VALUES ("

                                + "'" + params.getTable() + "', " + "'"

                                + OracleValues.DEFAULT_GEO_FIELD + "', "

                                + "MDSYS.SDO_DIM_ARRAY( " + "MDSYS.SDO_DIM_ELEMENT ('"

                                + dim_name[0] + "', " + minx + ", " + maxx + ", " + ORACLE_SPATIAL_DEFAULT_TOLERANCE

                                + " ), " + "MDSYS.SDO_DIM_ELEMENT ('" + dim_name[1] + "', "

                                + miny + ", " + maxy + ", " + ORACLE_SPATIAL_DEFAULT_TOLERANCE + " ))";

                if (dim > 2) {

                        resp = resp.substring(0, resp.length() - 1) + ",";

                        resp = resp + "MDSYS.SDO_DIM_ELEMENT ('" + dim_name[2]

                                        + "', 0.0, 100.0, " + ORACLE_SPATIAL_DEFAULT_TOLERANCE + " ))";

                        if (dim > 3) {

                                resp = resp.substring(0, resp.length() - 1) + ",";

                                resp = resp + "MDSYS.SDO_DIM_ELEMENT ('" + dim_name[3]

                                                + "', 0.0, 100.0, " + ORACLE_SPATIAL_DEFAULT_TOLERANCE + " ))";

                        }

                }

                if (withsrid) {

                        resp = resp + ", " + _ora_srid + " )";

                } else {

                        resp = resp + ", NULL )";

                }

                return resp;

        }

        /**

         * 

         */

        public void loadFeatureType(EditableFeatureType featureType,

                        JDBCStoreParameters storeParams) throws DataException {

                if ((storeParams.getDefaultGeometry() == null) && (storeParams instanceof OracleNewStoreParameters)) {

                        OracleNewStoreParameters osp = (OracleNewStoreParameters) storeParams;

                        String geoname = osp.getDefaultFeatureType().getDefaultGeometryAttributeName();

                        storeParams.setDefaultGeometry(geoname);

                }

                String sqlstr = storeParams.getSQL();

                if (sqlstr != null && sqlstr.trim().length() > 0) {

                        // loadFeatureType(featureType, storeParams, sqlstr);

                } else {

                        sqlstr = "SELECT * FROM " + storeParams.tableID() + " WHERE ROWNUM = 1";

                        storeParams.setSQL(sqlstr);

                }

                loadFeatureType(featureType, storeParams, sqlstr, storeParams

                                .getSchema(), storeParams.getTable());

                storeParams.setSQL(null);

                // super.loadFeatureType(featureType, storeParams);

        }

        /**

         * Fill <code>featureType</code> geometry attributes with ShapeType

         * information stored in the table USER_SDO_GEOMETRY_METADATA

         * 

         * @param conn

         * @param rsMetadata

         * @param featureType

         * @throws ReadException

         */

        protected void loadSRS_and_shapeType(Connection conn,

                        ResultSetMetaData rsMetadata, EditableFeatureType featureType,

                        String baseSchema, String baseTable) throws JDBCException {

                Statement st = null;

                ResultSet rs = null;

                String reserved_geocolname = null;

                try {

                        // Sacamos la lista de los attributos geometricos

                        EditableFeatureAttributeDescriptor attr;

                        ArrayList geoAttrs = new ArrayList();

                        Iterator iter = featureType.iterator();

                        while (iter.hasNext()) {

                                attr = (EditableFeatureAttributeDescriptor) iter.next();

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

                                        geoAttrs.add(attr);

                                }

                        }

                        if (geoAttrs.size() < 1) {

                                return;

                        }

                        // Preparamos una sql para que nos saque el resultado

                        StringBuilder strb = new StringBuilder();

                        strb.append("SELECT * FROM "

                                        + OracleValues.USER_ORACLE_GEOMETADATA_VIEW + " WHERE "

                                        + OracleValues.USER_ORACLE_GEOMETADATA_VIEW_TABLE_NAME

                                        + " = '" + baseTable + "'");

                        String sql = strb.toString();

                        st = conn.createStatement();

                        try {

                                rs = st.executeQuery(sql);

                        } catch (SQLException e) {

                                throw new JDBCExecuteSQLException(sql, e);

                        }

                        String srID;

                        EditableFeatureAttributeDescriptor auxdesc;

                                while (rs.next()) {

                                        String rsName =

                                                rs.getString(OracleValues.USER_ORACLE_GEOMETADATA_VIEW_COLUMN_NAME);

                                        reserved_geocolname = rsName;

                                        auxdesc = getAttrDescForCol(geoAttrs, rsName);

                                        if (auxdesc != null) {

                                                Object sridobj = rs.getObject("SRID");

                                                if (sridobj == null) {

                                                        auxdesc.setSRS(null);

                                                } else {

                                                        srID = (String) sridobj;

                                                        int epsg = OracleUtils.oracleSridToEpsg(srID);

                                                        String sepsg = "EPSG:" + Integer.toString(epsg);

                                                        auxdesc.setSRS(CRSFactory.getCRS(sepsg));

                                                }

                                        }

                                        if (featureType.getDefaultGeometryAttribute() == null) {

                                                ((DefaultEditableFeatureType) featureType).setDefaultGeometryAttributeName(reserved_geocolname);

                                        }

                        }

                } catch (java.sql.SQLException e) {

                        throw new JDBCSQLException(e);

                } finally {

                        try { rs.close(); } catch (Exception e) { };

                        try { st.close(); } catch (Exception e) { };

                }

                // guess shape type

                String geoColName = featureType.getDefaultGeometryAttributeName();

                if (geoColName == null) {

                        geoColName = reserved_geocolname; 

                }

                try {

                        String str_geo = "SELECT " + geoColName + " FROM " + baseTable +

                        " WHERE (" + geoColName + " IS NOT NULL) AND " + OracleUtils.EXPONENTIAL_INDICES_CONDITION; 

                        st = conn.createStatement();

                        try {

                                rs = st.executeQuery(str_geo);

                        } catch (SQLException e) {

                                throw new JDBCExecuteSQLException(str_geo, e);

                        }

            int aux = 0;

            int guess_type = TYPES.GEOMETRY;

            int guess_subtype = SUBTYPES.GEOM2D;

            STRUCT sample_geo;

            ArrayList shptypes = new ArrayList();

            int[] ty_subty;

            while (rs.next()) {

                sample_geo = (STRUCT) rs.getObject(1);

                ty_subty = OracleUtils.getGeoTypeSubTypeOfStruct(sample_geo); 

                aux = ty_subty[0];

                guess_subtype = ty_subty[1];

                shptypes.add(new Integer(aux));

            }

            if (shptypes.size() > 0) {

                    guess_type = OracleUtils.getShapeTypeFromArray(shptypes);

            } else {

                    logger.warn("Did not find geometries to sample. Assumed TYPE = GEOMETRY, SUBTYPE = 2D");

            }

            DefaultEditableFeatureAttributeDescriptor dfad = null;

            try {

                dfad = (DefaultEditableFeatureAttributeDescriptor) featureType.getDefaultGeometryAttribute();

                dfad.setGeometryType(guess_type);

                dfad.setGeometrySubType(guess_subtype);

            } catch (ClassCastException cce) {

                    logger.error("Unexpected non editable feature type. Did not set geo types.");

            }

                } catch (java.sql.SQLException e) {

                        throw new JDBCSQLException(e);

                } finally {

                        try {rs.close();} catch (Exception e) {        };

                        try {st.close();} catch (Exception e) { };

                }

        }

        private EditableFeatureAttributeDescriptor getAttrDescForCol(ArrayList list, String name) {

                int sz = list.size();

                for (int i=0; i<sz; i++) {

                        EditableFeatureAttributeDescriptor aux = (EditableFeatureAttributeDescriptor) list.get(i);

                        if (aux.getName().compareToIgnoreCase(name) == 0) {

                                return aux;

                        }

                }

                // not found

                return null;

        }

        /**

         * Add oracle geometry field and add spatial index

         * 

         * @param attr

         * @param table

         * @param schema

         * @return

         */

        public List<String> getSqlGeometryFieldAdd(FeatureAttributeDescriptor attr,

                        String table, String schema) {

                List<String> sqls = new ArrayList<String>();

                StringBuilder strb1 = new StringBuilder();

                strb1.append("Alter table ");

                if (schema != null && schema.length() > 0) {

                        strb1.append(schema);

                        strb1.append(".");

                }

                strb1.append(table);

                strb1.append(" add (");

                strb1.append(attr.getName());

                strb1.append(" SDO_GEOMETRY)");

                sqls.add(strb1.toString());

                String sqlindex = "CREATE INDEX "

                                + OracleUtils.getDerivedName(table, "SX") + " ON " + table

                                + " (\"" + attr.getName()

                                + "\") INDEXTYPE IS \"MDSYS\".\"SPATIAL_INDEX\" ";

                sqls.add(sqlindex);

                return sqls;

        }

//        protected void loadFeatureType(Connection conn,

//                        EditableFeatureType featureType, String sql, String[] pks,

//                        String defGeomName, String schema, String table)

//                        throws DataException {

//

//                Statement stAux = null;

//                ResultSet rs = null;

//                try {

//

//                        stAux = conn.createStatement();

//                        stAux.setFetchSize(1);

//

//                        try {

//                                rs = stAux.executeQuery(sql);

//                        } catch (SQLException e) {

//                                throw new JDBCExecuteSQLException(sql, e);

//                        }

//                        ResultSetMetaData rsMetadata = rs.getMetaData();

//

//                        List pksList = null;

//                        if (pks != null) {

//                                pksList = Arrays.asList(pks);

//                        }

//

//                        int i;

//                        int geometriesColumns = 0;

//                        String lastGeometry = null;

//

//                        EditableFeatureAttributeDescriptor attr;

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

//                                attr = getAttributeFromJDBC(featureType, conn, rsMetadata, i);

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

//                                        attr.setIsPrimaryKey(true);

//                                }

//                                if (attr.getDataType() == DataTypes.GEOMETRY) {

//                                        geometriesColumns++;

//                                        lastGeometry = attr.getName();

//                                        if (lastGeometry.equals(defGeomName)) {

//                                                featureType.setDefaultGeometryAttributeName(defGeomName);

//                                        }

//                                }

//                        }

//

//                        if (geometriesColumns > 0) {

//                                loadSRS_and_shapeType(conn, rsMetadata, featureType, schema,

//                                                table);

//                        }

//

//                        if (defGeomName == null && geometriesColumns == 1) {

//                                featureType.setDefaultGeometryAttributeName(lastGeometry);

//                                defGeomName = lastGeometry;

//                        }

//

//                } catch (java.sql.SQLException e) {

//                        throw new JDBCSQLException(e); // FIXME exception

//                } finally {

//                        try {

//                                rs.close();

//                        } catch (Exception e) {

//                        }

//                        try {

//                                stAux.close();

//                        } catch (Exception e) {

//                        }

//

//                }

//

//        }

}