| gvSIG desktop 1

/* gvSIG. Sistema de Informaci?n Geogr?fica de la Generalitat Valenciana

 *

 * Copyright (C) 2006 Prodevelop and Generalitat Valenciana.

 *

 * 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307,USA.

 *

 * For more information, contact:

 *

 *   Generalitat Valenciana

 *   Conselleria d'Infraestructures i Transport

 *   Av. Blasco Ib??ez, 50

 *   46010 VALENCIA

 *   SPAIN

 *

 *   +34 963862235

 *   gvsig@gva.es

 *   www.gvsig.gva.es

 *

 *    or

 *

 *   Prodevelop Integraci?n de Tecnolog?as SL

 *   Conde Salvatierra de ?lava , 34-10

 *   46004 Valencia

 *   Spain

 *

 *   +34 963 510 612

 *   +34 963 510 968

 *   gis@prodevelop.es

 *   http://www.prodevelop.es

 */

package es.prodevelop.cit.gvsig.fmap.drivers.jdbc.oracle;

import java.awt.Shape;

import java.awt.geom.Point2D;

import java.awt.geom.Rectangle2D;

import java.math.BigDecimal;

import java.sql.Connection;

import java.sql.DatabaseMetaData;

import java.sql.PreparedStatement;

import java.sql.ResultSet;

import java.sql.ResultSetMetaData;

import java.sql.SQLException;

import java.sql.Statement;

import java.sql.Timestamp;

import java.sql.Types;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.Hashtable;

import java.util.Iterator;

import java.util.Random;

import java.util.TreeMap;

import oracle.sql.ARRAY;

import oracle.sql.Datum;

import oracle.sql.NUMBER;

import oracle.sql.ROWID;

import oracle.sql.STRUCT;

import oracle.sql.StructDescriptor;

import oracle.sql.TIMESTAMP;

import org.apache.log4j.Logger;

import org.cresques.cts.ICoordTrans;

import org.cresques.cts.IProjection;

import com.hardcode.driverManager.IDelayedDriver;

import com.hardcode.gdbms.driver.exceptions.InitializeWriterException;

import com.hardcode.gdbms.driver.exceptions.ReadDriverException;

import com.hardcode.gdbms.driver.exceptions.WriteDriverException;

import com.hardcode.gdbms.engine.data.DataSource;

import com.hardcode.gdbms.engine.data.DataSourceFactory;

import com.hardcode.gdbms.engine.data.edition.DataWare;

import com.hardcode.gdbms.engine.spatial.fmap.FShapeGeneralPathX;

import com.hardcode.gdbms.engine.values.DoubleValue;

import com.hardcode.gdbms.engine.values.Value;

import com.hardcode.gdbms.engine.values.ValueFactory;

import com.iver.cit.gvsig.fmap.core.DefaultFeature;

import com.iver.cit.gvsig.fmap.core.FGeometryCollection;

import com.iver.cit.gvsig.fmap.core.FMultiPoint2D;

import com.iver.cit.gvsig.fmap.core.FNullGeometry;

import com.iver.cit.gvsig.fmap.core.FPoint2D;

import com.iver.cit.gvsig.fmap.core.FPolygon2D;

import com.iver.cit.gvsig.fmap.core.FPolyline2D;

import com.iver.cit.gvsig.fmap.core.FShape;

import com.iver.cit.gvsig.fmap.core.GeneralPathX;

import com.iver.cit.gvsig.fmap.core.ICanReproject;

import com.iver.cit.gvsig.fmap.core.IFeature;

import com.iver.cit.gvsig.fmap.core.IGeometry;

import com.iver.cit.gvsig.fmap.core.ShapeFactory;

import com.iver.cit.gvsig.fmap.core.v02.FConverter;

import com.iver.cit.gvsig.fmap.crs.CRSFactory;

import com.iver.cit.gvsig.fmap.drivers.ConnectionJDBC;

import com.iver.cit.gvsig.fmap.drivers.DBException;

import com.iver.cit.gvsig.fmap.drivers.DBLayerDefinition;

import com.iver.cit.gvsig.fmap.drivers.DefaultJDBCDriver;

import com.iver.cit.gvsig.fmap.drivers.DriverAttributes;

import com.iver.cit.gvsig.fmap.drivers.FieldDescription;

import com.iver.cit.gvsig.fmap.drivers.IConnection;

import com.iver.cit.gvsig.fmap.drivers.IFeatureIterator;

import com.iver.cit.gvsig.fmap.drivers.db.utils.ConnectionWithParams;

import com.iver.cit.gvsig.fmap.drivers.db.utils.SingleVectorialDBConnectionManager;

import com.iver.cit.gvsig.fmap.edition.IWriteable;

import com.iver.cit.gvsig.fmap.edition.IWriter;

import com.iver.cit.gvsig.fmap.layers.LayerFactory;

import com.iver.cit.gvsig.fmap.layers.XMLException;

import com.iver.utiles.NumberUtilities;

import com.iver.utiles.XMLEntity;

import com.vividsolutions.jts.algorithm.CGAlgorithms;

import com.vividsolutions.jts.geom.Coordinate;

import com.vividsolutions.jts.geom.Geometry;

import com.vividsolutions.jts.geom.GeometryFactory;

import com.vividsolutions.jts.geom.LineString;

import com.vividsolutions.jts.geom.LinearRing;

import com.vividsolutions.jts.geom.MultiPolygon;

import com.vividsolutions.jts.geom.Polygon;

import com.vividsolutions.jts.geom.impl.CoordinateArraySequence;

import es.prodevelop.cit.gvsig.fmap.drivers.jdbc.oracle.OracleSpatialUtils;

/**

 * Vectorial driver to access Oracle databases geometries

 * Should work on Oracle Locator.

 *

 * It contains switches to test different modules to perform the

 * translation oracle structs --> gvsig geometries:

 *

 * - Parsing the structs directly.

 * - Using Oracle's JGeometry static methods

 * - Using Geotools utilities

 *

 *  (currently, the driver parses the structs directly)

 *

 * @author jldominguez

 *

 */

public class OracleSpatialDriver extends DefaultJDBCDriver

    implements IDelayedDriver, ICanReproject, IWriteable {

    private static Logger logger = Logger.getLogger(OracleSpatialDriver.class.getName());

    private static int FETCH_SIZE = 15000;

    // constants

    public static final int GEODETIC_FULLEXTENT_SAMPLE_SIZE = 50;

    public static final String GEODETIC_SRID = "8307";

    // public static final String ASSUMED_ORACLE_SRID = "8307";

    // ------------------------------------------------

    public static final String NAME = "Oracle Spatial Database Driver";

    public static final int ID_COLUMN_INDEX = 1;

    public static final String ALL_ORACLE_GEOMETADATA_VIEW = "ALL_SDO_GEOM_METADATA";

    public static final String USER_ORACLE_GEOMETADATA_VIEW = "USER_SDO_GEOM_METADATA";

    public static final String ORACLE_EPSG_TABLE_NAME = "ORA_EPSG";

    public static final String ORACLE_EPSG_FILE_NAME = "ORA_EPSG.DBF";

    public static final String DEFAULT_GEO_FIELD = "GEOMETRY";

    // public static final String DEFAULT_GEO_FIELD = "MERGEDGEOMETRY";

    public static final String ORACLE_ID_FIELD = "ROWID";

    public static final String DEFAULT_ID_FIELD_CASE_SENSITIVE = "GID";

    public static final String ORACLE_GEO_SCHEMA = "MDSYS";

    public static final String CONN_STR_BEGIN = "jdbc:oracle:thin:";

    public static final int VARCHAR2_STANDARD_SIZE = 80;

    public static final int VARCHAR2_LONG_SIZE = 256;

    public static final int MAX_ID_LENGTH = 30;

    private final static GeometryFactory geomFactory = new GeometryFactory();

    public static final double IRRELEVANT_DISTANCE = 0.00000001;

        private static final long ID_MIN_DELAY = 1000;

        public static final String ORACLE_JAR_FILE_NAME = "oracle.jdbc.driver.OracleDriver";

    static {

        try {

            Class.forName(ORACLE_JAR_FILE_NAME);

        }

        catch (ClassNotFoundException e) {

            throw new RuntimeException(e);

        }

    }

    private OracleSpatialWriter writer = null;

    // switch variable

    private boolean use_geotools = false;

    private boolean tableHasSrid = true;

    // ------------------------------------------------

    private boolean isNotAvailableYet = true;

    private Value nullVal = ValueFactory.createNullValue();

    private IdLoaderThread idLoader;

    private DriverAttributes drvAtts;

    private int[] pkOneBasedIndexes;

    private String[] fieldNames;

    private String not_restricted_sql = "";

    private Rectangle2D workingAreaInViewsCS = null;

    private Rectangle2D workingAreaInTablesCS = null;

    private STRUCT workingAreaInTablesCSStruct = null;

    private String idFieldNames;

    private int oneBasedGeoColInd = 0;

    private int shapeType = -1;

    private boolean needsCollectionLayer = true;

    // ----------------------------------------------

    // one feature is cached to avoid querying for each attribute request:

    private IFeature singleCachedFeature = null;

    private long singleCachedFeatureRowNum = -1;

    // ----------------------------------------------

    private boolean cancelIDLoad = false;

    // ----------------------------------------------

    private String fullTableName = "";

    private String geoColName = "";

    private String oracleSRID;

    private String epsgSRID;

    private String destProj = "";

    private Rectangle2D full_Extent = null;

    private boolean emptyWhereClause = true;

    private boolean isGeogCS = false;

    private boolean hasRealiableExtent = true;

    // new hash map to perform queries by row number:

    private HashMap rowToId = new HashMap();

        private String destProjOracle;

        private boolean isDestGeogCS = false;

    public OracleSpatialDriver() {

        drvAtts = new DriverAttributes();

        drvAtts.setLoadedInMemory(false);

    }

        public String getWhereClause() {

            return lyrDef.getWhereClause();

        }

    /**

     * This method is called when the user creates a new oracle

     * table from a vectorial layer

     *

     * @param params this array simply contains the parameters <tt>Connection</tt> and

     * <tt>DBLayerDefinition</tt>

     */

    public void setData(Object[] params) {

        setData((IConnection) params[0], (DBLayerDefinition) params[1]);

    }

    private void adjustLyrDef() throws SQLException {

        DBLayerDefinition ldef = getLyrDef();

        int cnt = metaData.getColumnCount();

        FieldDescription[] _new = new FieldDescription[cnt];

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

            _new[i] = new FieldDescription();

            _new[i].setFieldName(metaData.getColumnName(i + 1));

            _new[i].setDefaultValue(ValueFactory.createNullValue());

            _new[i].setFieldAlias(_new[i].getFieldName());

            _new[i].setFieldLength(getFieldWidth(i));

            int _type = metaData.getColumnType(i + 1);

            _new[i].setFieldType(_type);

            if ((_type == Types.FLOAT) || (_type == Types.DOUBLE) ||

                    (_type == Types.DECIMAL) || (_type == Types.REAL)) {

                _new[i].setFieldDecimalCount(6);

            }

            else {

                _new[i].setFieldDecimalCount(0);

            }

        }

        ldef.setFieldsDesc(_new);

        setLyrDef(ldef);

    }

    /**

     * Standard initializing method.

     */

    public void setData(IConnection _conn, DBLayerDefinition lyrDef) {

        conn = _conn;

        // This metadata is required to store layer in GVP

        // without problems:

        ConnectionWithParams _cwp =

                SingleVectorialDBConnectionManager.instance().findConnection(conn);

                host = _cwp.getHost();

                port = _cwp.getPort();

                dbName = _cwp.getDb();

                connName = _cwp.getName();

                try {

                        if (conn.isClosed()) {

                                SingleVectorialDBConnectionManager.instance().closeAndRemove(_cwp);

                                _cwp = SingleVectorialDBConnectionManager.instance().getConnection(

                                                _cwp.getDrvName(),

                                                _cwp.getUser(),

                                                _cwp.getPw(),

                                                _cwp.getName(),

                                                _cwp.getHost(),

                                                _cwp.getPort(),

                                                _cwp.getDb(), true);

                        }

                } catch (DBException e1) {

                        logger.error("While trying to reconnect: " + e1.getMessage());

                        logger.error("Layer will not be reloaded!");

                }

        // ------------------

                OracleSpatialUtils.setUpperCase(lyrDef);

        lyrDef.setConnection(conn);

        String geo_can[];

                try {

                        geo_can = getGeometryFieldsCandidates(conn, lyrDef.getTableName());

                        OracleSpatialUtils.removeStructFields(lyrDef, geo_can);

                } catch (DBException e) {

                        logger.error("While removing STRUCT fields: " + e.getMessage());

                }

        setLyrDef(lyrDef);

        geoColName = lyrDef.getFieldGeometry();

        String tn = lyrDef.getTableName();

        if (tn.indexOf(".") == -1) {

                if (lyrDef.getSchema() == null) {

                        fullTableName = _cwp.getUser().toUpperCase() + "." + tn;

                } else {

                        fullTableName = lyrDef.getSchema() + "." + tn;

                }

        } else {

                fullTableName = tn;

        }

        not_restricted_sql = "select " + getStandardSelectExpression() +

            " from " + getTableName() + " c ";

        // various metadata settings

        // getMetaDataInThisThread();

        cleanWhereClause();

        loadSdoMetadata();

        oneRowMetadata();

        setDestProjection(lyrDef.getSRID_EPSG());

        workingAreaInViewsCS = lyrDef.getWorkingArea();

        if ((workingAreaInViewsCS != null) && (epsgSRID != null)) {

            IProjection viewProj = CRSFactory.getCRS("EPSG:" + destProj);

            IProjection tableProj = CRSFactory.getCRS("EPSG:" + epsgSRID);

            ICoordTrans reprojecter = viewProj.getCT(tableProj);

                workingAreaInTablesCS = reprojecter.convert(workingAreaInViewsCS);

            workingAreaInTablesCSStruct = shapeToStruct(workingAreaInTablesCS,

                    FShape.NULL, tableHasSrid, false, true);

        }

        cancelIDLoad = false;

        idLoader = new IdLoaderThread(this);

        idLoader.start();

    }

        /**

     * Utility method to load IDs in a different thred, so that gvsig's gui

     * does not get blocked.

     *

     */

    public void getMetaDataInThisThread() {

        getMetadata();

    }

    private void getMetadata() {

            long id_load_start = System.currentTimeMillis();

        setIdRowTable();

        long id_load_end = System.currentTimeMillis();

        long delay = id_load_end - id_load_start;

        if (delay < ID_MIN_DELAY) {

                logger.info("Ids thread delayed by: " + (ID_MIN_DELAY - delay) + " ms.");

                try {

                                Thread.sleep(ID_MIN_DELAY - delay);

                        } catch (InterruptedException e) {

                                logger.error("While delaying ids thread: " + e.getMessage());

                        }

        }

        if (!hasRealiableExtent) {

                full_Extent = getEstimatedExtent(

                                getTableName(), geoColName, conn, 20, 1.5, isGeogCS);

        }

        if (cancelIDLoad) {

            return;

        }

    }

    private String getOracleSridFromCurrentRecord(ResultSet _rs)

        throws SQLException {

        Object obj = _rs.getObject("SRID");

        if (obj == null) {

            logger.warn("No SRID found for this table.");

            tableHasSrid = false;

            return null;

        }

        return obj.toString();

    }

    private Rectangle2D getFullExtentFromCurrentRecord(ResultSet _rs)

        throws SQLException {

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

        if (dim_info_array == null) {

            // no full extent found:

            return null;

        }

        else {

            Datum[] da = dim_info_array.getOracleArray();

            STRUCT sx = (STRUCT) da[0];

            STRUCT sy = (STRUCT) da[1];

            try {

                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;

                }

                return getRectangle(minx, maxx, miny, maxy);

                // fullExtentJTS = shapeToGeometry(fullExtent);

            }

            catch (Exception ex) {

                    logger.error("While getting full extent from metadata table.");

                return null;

            }

        }

    }

    private void loadSdoMetadata() {

        try {

            Statement _st = ((ConnectionJDBC)conn).getConnection().createStatement();

            String[] tokens = getTableName().split("\\u002E", 2);

            String qry;

            if (tokens.length > 1)

            {

                    qry = "select * from " + ALL_ORACLE_GEOMETADATA_VIEW +

                " where OWNER = '" + tokens[0] + "' AND TABLE_NAME = '" +

                tokens[1] + "' AND COLUMN_NAME = '" + geoColName + "'";

            }

            else

            {

                    qry = "select * from " + ALL_ORACLE_GEOMETADATA_VIEW +

                " where TABLE_NAME = " + "'" + getTableName()

                + "' AND COLUMN_NAME = '"

                + geoColName + "'";

            }

            ResultSet _rs = _st.executeQuery(qry);

            if (_rs.next()) {

                oracleSRID = getOracleSridFromCurrentRecord(_rs);

                isGeogCS = OracleSpatialUtils.getIsGCS(oracleSRID, tableHasSrid);

                try {

                                        epsgSRID = oracleSridToEpsgSrid(oracleSRID);

                                } catch (Exception e) {

                                        logger.error("Unknown oracle SRID: " + oracleSRID);

                                        tableHasSrid = false;

                                }

                full_Extent = getFullExtentFromCurrentRecord(_rs);

                hasRealiableExtent = realiableExtent(full_Extent, isGeogCS);

                if (!hasRealiableExtent) {

                        full_Extent = getFastEstimatedExtent(

                                            getTableName(), geoColName, conn, 20, 10, isGeogCS);

                }

                _rs.close();

                _st.close();

            }

            else {

                throw new SQLException("Empty resultset from this query: " +

                    qry);

            }

        }

        catch (SQLException se) {

                logger.error("While getting SDO metadata: " + se.getMessage());

        }

    }

    /**

     * Utility method to get a geometry from a struct.

     *

     * @param theStruct the struct to be converted

     * @param use_gtools switch to use geotools classes or not

     * @return the geometry

     * @throws SQLException

     */

    public IGeometry getGeometryUsing(STRUCT theStruct, boolean use_gtools)

        throws SQLException {

        IGeometry _igeom = null;

        if (theStruct == null) {

            return OracleSpatialUtils.NULL_GEOM;

        }

        if (use_gtools) { // geotools

//            _igeom = getGeotoolsIGeometry(theStruct);

        }

        else { // jgeometry

            _igeom = getFMapGeometry(theStruct, false);

        }

        return _igeom;

    }

    /**

     * Utility method to transform a struct into a IGeometry.

     *

     * @param st the struct to be converted

     * @param complex comes from a complex sdo geometry

     * @return the IGeometry

     */

    private IGeometry getFMapGeometry(STRUCT st, boolean complex) {

            if (st == null) {

                    return new FNullGeometry();

            }

        Datum[] the_data = null;

        try {

            the_data = st.getOracleAttributes();

            int jgtype = ((NUMBER) the_data[0]).intValue() % 1000;

            jgtype = OracleSpatialUtils.oracleGTypeToFShapeType(jgtype, complex);

            int dim = ((NUMBER) the_data[0]).intValue() / 1000;

            if (dim < 2) {

                dim = 2;

            }

            IGeometry ig = null;

            if (OracleSpatialUtils.isActuallyACollection(the_data)) {

                jgtype = FShape.MULTI;

            }

            switch (jgtype) {

            case FShape.MULTI:

                // int srid = ((NUMBER) the_data[1]).intValue();

                ig = getFMapGeometryCollection(the_data, dim);

                break;

            case FShape.POINT:

                ig = OracleSpatialUtils.getFMapGeometryPoint(the_data, dim);

                break;

            case FShape.LINE:

                ig = OracleSpatialUtils.getFMapGeometryMultiLineString(the_data, dim);

                break;

            case FShape.POLYGON:

                ig = OracleSpatialUtils.getFMapGeometryMultipolygon(the_data, dim);

                break;

            }

            return ig;

        }

        catch (SQLException e) {

            logger.error(e);

        }

        return null;

    }

    private Rectangle2D getRectangle(double minx, double maxx, double miny,

        double maxy) {

        Rectangle2D resp = new Rectangle2D.Double(minx, miny, maxx - minx,

                maxy - miny);

        return resp;

    }

    private void oneRowMetadata() {

        try {

            String _sql = "select " + getStandardSelectExpression() + ", c." +

                geoColName + " from " + getTableName() + " c ";

            st = ((ConnectionJDBC)conn).getConnection().createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,

                    ResultSet.CONCUR_READ_ONLY);

            ResultSet _rs = st.executeQuery(_sql + " where c." + geoColName + " is not NULL AND rownum = 1");

            if (_rs.next()) {

                STRUCT sample_geo = (STRUCT) _rs.getObject(geoColName);

                shapeType = OracleSpatialUtils.getShapeTypeOfStruct(sample_geo);

            }

            else {

                shapeType = FShape.MULTI;

            }

            // -----------------------

            _rs = st.executeQuery(not_restricted_sql + " where (rownum = 1)");

            metaData = _rs.getMetaData();

            userName = ((ConnectionJDBC)conn).getConnection().getMetaData().getUserName();

            // geoColInd = _rs.findColumn(geoColName);

            oneBasedGeoColInd = metaData.getColumnCount() + 1;

            DatabaseMetaData dbmd = ((ConnectionJDBC)conn).getConnection().getMetaData();

            pkOneBasedIndexes = getPKIndexes(dbmd, _rs);

            int cnt = metaData.getColumnCount();

            fieldNames = new String[cnt];

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

                fieldNames[i] = metaData.getColumnName(i + 1);

            }

            getIdFieldNames();

            adjustLyrDef();

            _rs.close(); // st no debe cerrarse ya que las llamadas a metadata lo encesitan

        }

        catch (SQLException se) {

            logger.error("While getting metadata. " + se.getMessage());

        }

    }

    private String getIdFieldNames() {

        try {

            idFieldNames = "";

            for (int i = 0; i < pkOneBasedIndexes.length; i++) {

                idFieldNames = idFieldNames +

                    metaData.getColumnName(pkOneBasedIndexes[i]) + ", ";

            }

        }

        catch (SQLException se) {

        }

        idFieldNames = idFieldNames.substring(0, idFieldNames.length() - 2);

        return idFieldNames;

    }

    private int[] getPKIndexes(DatabaseMetaData metaData, ResultSet table_rs) {

        int[] _res = new int[1];

        _res[0] = 1;

        return _res;

    }

    public String getSqlTotal() {

        // TODO Auto-generated method stub

        return "";

    }

    public String getCompleteWhere() {

        // TODO Auto-generated method stub

        return "";

    }

    /**

     * Gets the feature iterator for a given SQL sentence (ignores previous filters

     * and uses directly that sentence to query the table).

     */

    public IFeatureIterator getFeatureIterator(String sql)

        throws ReadDriverException {

        if (isNotAvailableYet) {

                return new AnEmptyFeatureIterator();

            // return null;

        }

        singleCachedFeatureRowNum = -1;

        Object[] rs_st = getViewResultSet(null, sql, tableHasSrid);

        ResultSet localrs = (ResultSet) rs_st[0];

        Statement _st = (Statement) rs_st[1];

        return new OracleSpatialFeatureIterator(this, localrs, _st,

            oneBasedGeoColInd, use_geotools, false, null);

    }

    /**

     * Gets Oracle particular connection string beginning: "jdbc:oracle:thin:"

     */

    public String getConnectionStringBeginning() {

        // oracle

        return CONN_STR_BEGIN;

    }

    public void open() { // throws DriverException {

    }

    /**

     * Gets Oracle's default port: 1521

     */

    public int getDefaultPort() {

        // oracle port

        return 1521;

    }

    /**

     * Gets the feature iterator for a given rectangle (the view's bounding box)

     * and a SRS.

     */

    public IFeatureIterator getFeatureIterator(Rectangle2D r, String strEPSG)

        throws ReadDriverException {

        if (isNotAvailableYet) {

                return new AnEmptyFeatureIterator();

            // return null;

        }

        singleCachedFeatureRowNum = -1;

        STRUCT local_st = shapeToStruct(r, FShape.NULL, tableHasSrid, false, true);

        Object[] rs_st = getViewResultSet(local_st, null, tableHasSrid);

        ResultSet localrs = (ResultSet) rs_st[0];

        Statement _st = (Statement) rs_st[1];

        return new OracleSpatialFeatureIterator(this, localrs, _st,

            oneBasedGeoColInd, use_geotools, false, null);

    }

    private Rectangle2D intersectWithWorkingArea(Rectangle2D r) {

        if (workingAreaInTablesCS == null) return r;

        return OracleSpatialUtils.doIntersect(r, workingAreaInTablesCS);

    }

    /**

     * This method reverts to the one without the fields specification.

     * The fields have been selected from the start.

     */

    public IFeatureIterator getFeatureIterator(Rectangle2D r, String strEPSG,

        String[] alphaNumericFieldsNeeded) throws ReadDriverException {

        if (isNotAvailableYet) {

                return new AnEmptyFeatureIterator();

            // return null;

        }

        singleCachedFeatureRowNum = -1;

        if ((alphaNumericFieldsNeeded == null) || (alphaNumericFieldsNeeded.length == 0)) {

            return getFeatureIterator(r, strEPSG);

        } else {

            STRUCT local_st = shapeToStruct(r, FShape.NULL, tableHasSrid, false, true);

            Object[] rs_st = getViewResultSet(local_st, null, tableHasSrid);

            ResultSet localrs = (ResultSet) rs_st[0];

            Statement _st = (Statement) rs_st[1];

            return new OracleSpatialFeatureIterator(this, localrs, _st,

                oneBasedGeoColInd, use_geotools, true, alphaNumericFieldsNeeded);

        }

    }

    private String getSqlFor(String[] alphaNumericFieldsNeeded, String sdo_inter) {

            String idswhere = getIdsQueryWhereClause(false);

        String custom_sel = getCustomSelect(alphaNumericFieldsNeeded, sdo_inter, idswhere);

                return custom_sel;

        }

        public String getGeometryField(String fieldName) {

        return fieldName;

    }

    public DriverAttributes getDriverAttributes() {

        return drvAtts;

    }

    /**

     * Gets the requested geometry. Always performs a new query in this case.

     * This should be a rare way to get the geometries. The standard way is by using

     * the iterators.

     */

    public IGeometry getShape(int _ind) throws ReadDriverException {

        if (isNotAvailableYet) {

            return OracleSpatialUtils.NULL_GEOM;

        }

        ROWID r_id = (ROWID) rowToId.get(new Integer(_ind));

        String _sql = "select " + geoColName + " from " + getTableName() +

            " where rowid = ?";

        try {

            java.sql.PreparedStatement ps = ((ConnectionJDBC)conn).getConnection().prepareStatement(_sql);

            ps.setObject(1, r_id);

            // Statement stmnt = conn.createStatement();

            ps.execute();

            ResultSet _res = ps.getResultSet();

            if (_res.next()) {

                STRUCT _st = (oracle.sql.STRUCT) _res.getObject(1); // geocolind);

                IGeometry theGeom = getGeometryUsing(_st, use_geotools);

                _res.close();

                ps.close();

                return theGeom;

            }

            else {

                logger.error("Unable to get shape: " + _ind +

                    " (probably due to edition)");

                return OracleSpatialUtils.NULL_GEOM;

            }

        }

        catch (SQLException se) {

            throw new ReadDriverException(getName(), se);

        }

    }

    public boolean isWritable() {

        return true;

    }

    public String getName() {

        return NAME;

    }

    public int[] getPrimaryKeys() throws ReadDriverException {

        return pkOneBasedIndexes;

    }

    private void setIdRowTable() {

        hashRelate = new Hashtable();

        java.sql.PreparedStatement ps = null;

        try {

            String _sql = getIdAndElemInfoFullResulltSetQuery();

            logger.debug("SQL para leer ids: " + _sql);

            Statement st = null;

            st = ((ConnectionJDBC)conn).getConnection().createStatement(

                            ResultSet.TYPE_FORWARD_ONLY,

                            ResultSet.CONCUR_READ_ONLY);

            // st = ((ConnectionJDBC)conn).getConnection().createStatement();

             st.setFetchSize(FETCH_SIZE);

             logger.info("FETCH_SIZE = " + FETCH_SIZE);

            ResultSet _r = null;

            _r = st.executeQuery(_sql);

            ROWID ri = null;

            int row = 0;

            String gid;

            Value aux = null;

            // ----------------------------------- types init

            ArrayList types = new ArrayList();

            int types_aux = 0;

            ARRAY info_aux;

            int[] info_aux_int;

            int size;

            // ----------------------------------- types init

            logger.debug("Beginning of result set:");

            while (_r.next()) {

                // ---------------------------------------

                ri = (ROWID) _r.getObject(1);

                gid = ri.stringValue();

                aux = ValueFactory.createValue(gid);

                Integer intobj = new Integer(row);

                hashRelate.put(aux, intobj);

                rowToId.put(intobj, ri);

                if ((row % 5000) == 0) {

                    // ------------------------------------------- cancel load

                    if (cancelIDLoad) {

                        hashRelate.clear();

                        rowToId.clear();

                        return;

                    }

                    // -------------------------------------------

                    String fmt = OracleSpatialUtils.getFormattedInteger(row);

                    logger.info("IDs read: " + fmt);

                }

                row++;

                // --------------------------------------- types

                info_aux = (ARRAY) _r.getObject(2);

                if (info_aux == null) {

                    // logger.debug("NULL info array found in record: " + row);

                }

                else {

                    info_aux_int = info_aux.getIntArray();

                    size = info_aux_int.length / 3;

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

                        types_aux = info_aux_int[(3 * i) + 1];

                        types.add(new Integer(types_aux % 1000));

                    }

                }

                // --------------------------------------- types end

            }

            _r.close();

//            ps.close();

            st.close();

            numReg = row;

            needsCollectionLayer = OracleSpatialUtils.hasSeveralGeometryTypes(types, false);

            if (needsCollectionLayer) {

                shapeType = FShape.MULTI;

            }

        }

        catch (SQLException e) {

                logger.error("While setting id-row hashmap: " +

                e.getMessage());

        }

    }

    public int getFieldCount() throws ReadDriverException {

        try {

            return metaData.getColumnCount();

        }

        catch (SQLException e) {

                logger.error("While getting field count: " + e.getMessage());

            throw new ReadDriverException(getName(), e);

        }

    }

    public String[] getFieldNames() {

        return fieldNames;

    }

    public String getTotalFields() {

        String strAux = "";

        for (int i = 0; i < fieldNames.length; i++) {

            if (i == 0) {

                strAux = fieldNames[i];

            }

            else {

                strAux = strAux + ", " + fieldNames[i];

            }

        }

        return strAux;

    }

    public int getFieldType(int idField) throws ReadDriverException {

        int i = 0;

        try {

            i = idField + 1; // idField viene basado en 0

            int __type = metaData.getColumnType(i);

            int size = metaData.getPrecision(i);

            int dec_pos = metaData.getScale(i);

            // we must add this entry because we did not remove the 'geometry' column

            if (__type == Types.STRUCT) {

                return Types.VARCHAR; // .STRUCT;

                // ----------------------------------------------------------------------

            }

            if (__type == Types.VARCHAR) {

                return Types.VARCHAR;

            }

            if (__type == Types.FLOAT) {

                return Types.FLOAT;

            }

            if (__type == Types.DOUBLE) {

                return Types.DOUBLE;

            }

            if ((__type == Types.INTEGER)

                            || (__type == Types.SMALLINT)

                            || (__type == Types.TINYINT)

                            || (__type == Types.BIGINT)

                            || ((__type == Types.NUMERIC) && (dec_pos == 0))

                            ) {

                    if (size > 10) {

                            return Types.BIGINT;

                    } else {

                            return Types.INTEGER;

                    }

            }

            if (__type == Types.BIT) {

                return Types.BIT;

            }

            if (__type == Types.DATE) {

                return Types.DATE;

            }

            if (__type == Types.DECIMAL) {

                return Types.DOUBLE;

            }

            if (__type == Types.NUMERIC) {

                    return Types.DOUBLE;

            }

            if (__type == Types.DATE) {

                return Types.DATE;

            }

            if (__type == Types.TIME) {

                return Types.TIME;

            }

            if (__type == Types.TIMESTAMP) {

                return Types.TIMESTAMP;

            }

        }

        catch (SQLException e) {

            logger.error("Unknown field type of : " + i);

            throw new ReadDriverException(getName(), e);

        }

        return -1;

    }

    public String getFieldName(int fieldId) throws ReadDriverException {

        return fieldNames[fieldId];

    }

    public int getFieldWidth(int fieldId) {

        int i = -1;

        try {

            int aux = fieldId + 1; // fieldId viene basado en 0

            i = metaData.getColumnDisplaySize(aux);

        }

        catch (SQLException e) {

            logger.error("While getting field width: " + e.getMessage());

        }

        if (i < 0) {

            i = 255;

        }

        return i;

    }

    public Value getFieldValue(long rowIndex, int field_Id) throws ReadDriverException {

        if (isNotAvailableYet) {

            return nullVal;

        }

        if ((singleCachedFeature != null) &&

                (rowIndex == singleCachedFeatureRowNum)) {

            return singleCachedFeature.getAttributes()[field_Id];

        }

        // return ValueFactory.createNullValue();

        ResultSet _r = null;

        java.sql.PreparedStatement ps = null;

        try {

            String rnq = getSearchId();

            ROWID _id = (ROWID) rowToId.get(new Integer((int) rowIndex));

            ps = ((ConnectionJDBC)conn).getConnection().prepareStatement(rnq);

            ps.setObject(1, _id);

            ps.execute();

            _r = ps.getResultSet();

            if (!_r.next()) {

                _r.close();

                ps.close();

                    throw new SQLException("No row for ROWID: " + _id.toString() + ". Possibly deleted from another app.");

            }

        } catch (SQLException se) {

                logger.error("While getting row " + rowIndex + " : " + se.getMessage());

                return ValueFactory.createNullValue();

        }

        IFeature ife = null;

        Value[] atts = null;

        try {

            ROWID ri = (ROWID) _r.getObject(1);

            atts = getAttributes(_r, true);

            String gid = ri.stringValue();

            STRUCT _st = (oracle.sql.STRUCT) _r.getObject(oneBasedGeoColInd);

            IGeometry theGeom = getGeometryUsing(_st, use_geotools);

            ife = new DefaultFeature(theGeom, atts, gid);

            _r.close();

            ps.close();

        } catch (SQLException se) {

            logger.error("Error while doing next(): " + se.getMessage(), se);

            return ValueFactory.createNullValue();

        }

        // -------------------------------

        singleCachedFeature = ife;

        singleCachedFeatureRowNum = rowIndex;

        // -------------------------------

        if (atts == null) {

            return ValueFactory.createNullValue();

        } else {

            return atts[field_Id];

        }

    }

    public Rectangle2D getFullExtent() {

            return full_Extent;

    }

    private IGeometry getFMapGeometryCollection(Datum[] the_data, int dim) {

        // int __srid) {

            NUMBER _srid = new NUMBER(0);

        NUMBER main_type = new NUMBER((dim * 1000) +

                OracleSpatialUtils.getStructType(the_data));

        Datum[] all_info_array = null;

        Object[] elems_info_aray = null;

        Datum[] all_ords = null;

        Object[] ords_of_groups = null;

        Object[] _elems_info_aray = null;

        try {

            all_info_array = ((ARRAY) the_data[3]).getOracleArray();

            elems_info_aray = OracleSpatialUtils.groupByElement(all_info_array);

            all_ords = ((ARRAY) the_data[4]).getOracleArray();

            ords_of_groups = OracleSpatialUtils.getOrdOfGroups(all_ords, elems_info_aray);

            _elems_info_aray = new Object[elems_info_aray.length];

        }

        catch (SQLException e) {

            logger.error("Unexpected error: " + e.getMessage());

        }

        for (int i = 0; i < elems_info_aray.length; i++) {

            _elems_info_aray[i] = OracleSpatialUtils.updateIndexes((Datum[]) elems_info_aray[i]);

        }

        // _elems_info_aray, ords_of_groups

        int no_of_elems = ords_of_groups.length;

        IGeometry[] geoms = new IGeometry[no_of_elems];

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

            Datum[] item_info_array = null;

            Datum[] item_ords = null;

            NUMBER gtype = null;

            try {

                item_info_array = (Datum[]) _elems_info_aray[i];

                item_ords = (Datum[]) ords_of_groups[i];

                gtype = new NUMBER((dim * 1000) +

                        (item_info_array[1].intValue() % 1000));

                if (tableHasSrid) {

                        _srid = new NUMBER(Integer.parseInt(oracleSRID));

                }

            }

            catch (SQLException se) {

                logger.error("Unexpected error: " + se.getMessage());

            }

            // if it's the first geometry, the type is the collection's main type (no?) - no

            // if (i == 0) gtype = main_type;

            STRUCT itemst = null;

            if (tableHasSrid) {

                itemst = OracleSpatialUtils.createStruct(gtype, _srid,

                        item_info_array, item_ords, ((ConnectionJDBC)conn).getConnection());

            }

            else {

                itemst = OracleSpatialUtils.createStruct(gtype, null,

                        item_info_array, item_ords, ((ConnectionJDBC)conn).getConnection());

            }

            geoms[i] = getFMapGeometry(itemst, true);

        }

        return new FGeometryCollection(geoms);

    }

    private void cleanWhereClause() {

        emptyWhereClause = false;

        String aux = getWhereClauseWithoutWhere();

        for (int i = 0; i < aux.length(); i++)