Application: gvSIG desktop

/* 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.DATE;

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;

/**

 * 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 ORACLE_GEOMETADATA_VIEW = "ALL_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 = "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 NVARCHAR2_MAX_SIZE = 4000;

    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;

    // utility object to convert geometries.

//    private GeometryConverter geotools_conv;

    // switch variable

    private boolean use_geotools = false;

    private boolean tableHasSrid = true;

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

    private boolean isNotAvailableYet = true;

    private IGeometry nullGeom = new FNullGeometry();

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

        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();

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

                setUpperCase(lyrDef);

        lyrDef.setConnection(conn);

        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();

    }

        private void setUpperCase(DBLayerDefinition def) {

                String aux = def.getCatalogName();

                if (aux != null) def.setCatalogName(aux.toUpperCase());

                aux = def.getSchema();

                if (aux != null) def.setSchema(aux.toUpperCase());

                aux = def.getFieldID();

                if (aux != null) def.setFieldID(aux.toUpperCase());

                aux = def.getFieldGeometry();

                if (aux != null) def.setFieldGeometry(aux.toUpperCase());

                String flds[] = def.getFieldNames();

                if (flds != null) {

                        for (int i=0; i<flds.length; i++) flds[i] = flds[i].toUpperCase();

                        def.setFieldNames(flds);

                }

        }

        /**

     * 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 boolean needsCollectionLayer() {

        try {

            // SELECT DISTINCT(C.GEOM.SDO_GTYPE) FROM COMUICV C

            // String qry = "select distinct(c."  + geoColName + ".SDO_GTYPE) from " + getTableName() + " c";

            String qry = "select c." + geoColName + ".SDO_ELEM_INFO from " +

                getTableName() + " c";

            // SDO_ELEM_INFO

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

            ResultSet _rs = _st.executeQuery(qry);

            ArrayList types = new ArrayList();

            int aux = 0;

            ARRAY info_aux;

            int[] info_aux_int;

            int size;

            while (_rs.next()) {

                // aux = _rs.getInt(1);

                info_aux = (ARRAY) _rs.getObject(1);

                info_aux_int = info_aux.getIntArray();

                size = info_aux_int.length / 3;

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

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

                }

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

            }

            _rs.close();

            _st.close();

            boolean resp = hasSeveralGeometryTypes(types, false);

            return resp;

        }

        catch (Exception se) {

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

        }

        return false;

    }

    private boolean hasSeveralGeometryTypes(ArrayList tt, boolean are_dims) {

        if (tt.size() == 0) {

            return false;

        }

        HashMap m = new HashMap();

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

            Integer integ = (Integer) tt.get(i);

            int val = integ.intValue();

            if ((val == 4) && (!are_dims)) {

                return true;

            }

            m.put("" + (val % 4), "a type");

        }

        Iterator iter = m.keySet().iterator();

        iter.next();

        return iter.hasNext();

    }

    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 " + ORACLE_GEOMETADATA_VIEW +

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

                tokens[1] + "'";

            }

            else

            {

                    qry = "select * from " + ORACLE_GEOMETADATA_VIEW +

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

            }

            ResultSet _rs = _st.executeQuery(qry);

            if (_rs.next()) {

                oracleSRID = getOracleSridFromCurrentRecord(_rs);

                isGeogCS = 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 find out if a coordinate system is geodetic or not.

     *

     * @param oracleSRID2 the coordinate system's oracle code

     * @param thas whether the table has a coordinate system set.

     * if not, the method returns false.

     * @return whether the coordinate system is geodetic or not.

     */

    public static boolean getIsGCS(String oracleSRID2, boolean thas) {

        if (!thas) return false;

        if (oracleSRID2 == null) return false;

        int ora_cs = 0;

        try {

            ora_cs = Integer.parseInt(oracleSRID2);

        }

        catch (Exception ex) {

            return false;

        }

        if (((ora_cs >= 8000) && (ora_cs <= 8999)) || (ora_cs == 524288)) {

            return true;

        } else {

                return false;

        }

    }

    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 (rownum = 1)");

            if (_rs.next()) {

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

                shapeType = 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 int getShapeTypeOfStruct(STRUCT sample) throws SQLException {

        int code = ((NUMBER) sample.getOracleAttributes()[0]).intValue();

        int type_part = code % 10;

        int dim_part = code / 1000;

        int z_added = 0;

        if ((dim_part == 3) || (dim_part == 4)) {

                z_added = 512;

        }

        switch (type_part) {

        case 1:

            return z_added + FShape.POINT;

        case 2:

            return z_added + FShape.LINE;

        case 3:

            return z_added + FShape.POLYGON;

        case 4:

            return z_added + FShape.MULTI;

        case 5:

            return z_added + FShape.MULTIPOINT;

        case 6:

            return z_added + FShape.LINE;

        case 7:

            return z_added + FShape.POLYGON;

        }

        logger.error("Unknown geometry type: " + code);

        return FShape.NULL;

    }

    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);

    }

    /**

     * 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);

    }

    private Rectangle2D intersectWithWorkingArea(Rectangle2D r) {

        if (workingAreaInTablesCS == null) return r;

        return 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;

        return getFeatureIterator(r, strEPSG);

    }

    public String getGeometryField(String fieldName) {

        return fieldName;

        // return "ASBINARY(" + 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 nullGeom;

        }

        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 nullGeom;

            }

        }

        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;

    }

    /*

    public void write(DataWare dataWare) throws ReadDriverException {

    }

    */

    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 = 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);

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

                return Types.INTEGER;

            }

            if (__type == Types.SMALLINT) {

                return Types.SMALLINT;

            }

            if (__type == Types.TINYINT) {

                return Types.TINYINT;

            }

            if (__type == Types.BIGINT) {

                return Types.BIGINT;

            }

            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 Value[] getAttributes(ResultSet rs) {

        Value[] res = null;

        int fcount = 0;

        try {

            fcount = rs.getMetaData().getColumnCount();

            res = new Value[fcount];

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

                Object obj = rs.getObject(i + 1);

                String objToString = null;

                if (obj == null) {

                        res[i] = ValueFactory.createNullValue();

                } else {

                    if (obj instanceof String) {

                        objToString = (String) obj;

                        res[i] = ValueFactory.createValue(objToString);

                    } else {

                        if (obj instanceof ROWID) {

                            objToString = ((ROWID) obj).stringValue();

                            res[i] = ValueFactory.createValue(objToString);

                        } else {

                            if (obj instanceof STRUCT) {

                                objToString = "STRUCT";

                                res[i] = ValueFactory.createValue(objToString);

                            } else {

                                if (obj instanceof TIMESTAMP) {

                                        TIMESTAMP aux = (TIMESTAMP) obj;

                                    objToString = aux.stringValue();

                                    Timestamp ts = flexibleTimeStamp(objToString);

                                    res[i] = ValueFactory.createValue(ts);

                                } else {

                                        objToString = obj.toString();

                                        int _type = getFieldType(i);

                                    if (obj instanceof DATE) {

                                            objToString = objToString.replace('-', '/');

                                    }

                                    res[i] = ValueFactory.createValueByType(

                                                    objToString, _type);

                                }

                            }

                        }

                    }

                }

            }

        } catch (Exception se) {

                logger.error("While getting resultset attribute values: " + se.getMessage());

                res = new Value[fcount];

                for (int i=0; i<fcount; i++) res[i] = ValueFactory.createNullValue();

        }

        return res;

    }

    public Value[] getAttributesUsingMainMetadata(ResultSet rs) {

        Value[] res = null;

        try {

            int fcount = metaData.getColumnCount();

            res = new Value[fcount];

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

                Object obj = rs.getObject(i + 1);

                String objToString = null;

                int _type = -1;

                if (obj instanceof String) {

                    objToString = (String) obj;

                    _type = Types.VARCHAR;

                }

                else {

                    if (obj instanceof ROWID) {

                        objToString = ((ROWID) obj).stringValue();

                        _type = Types.VARCHAR;

                    }

                    else {

                        if (obj instanceof STRUCT) {

                            objToString = "STRUCT";

                            _type = Types.VARCHAR;

                        }

                        else {

                            objToString = (obj == null) ? "NULL" : obj.toString();

                            try {

                                                                _type = getFieldType(i);

                                                        } catch (ReadDriverException e) {

                                                                logger.error("TYPE = -1 due to exception");

                                                        }

                        }

                    }

                }

                // /*

                if (_type == -1) {

                    obj = null;

                }

                // */

                if (obj == null) {

                    res[i] = ValueFactory.createNullValue();

                }

                else {

                    if (_type == Types.DATE) {

                        objToString = objToString.replace('-', '/');

                    }

                    res[i] = ValueFactory.createValueByType(objToString, _type);

                }

            }

        } catch (Exception se) {

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

            return null;

        }

        return res;

    }

    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;

    }