Application: gvSIG desktop

package com.iver.cit.gvsig.fmap.drivers.jdbc.oracle;

import java.awt.Shape;

import java.awt.geom.Point2D;

import java.awt.geom.Rectangle2D;

import java.io.File;

import java.io.IOException;

import java.sql.Connection;

import java.sql.DatabaseMetaData;

import java.sql.ResultSet;

import java.sql.ResultSetMetaData;

import java.sql.SQLException;

import java.sql.Statement;

import java.sql.Types;

import java.text.ParseException;

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.jdbc.OracleConnection;

import oracle.spatial.geometry.JGeometry;

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 org.apache.log4j.Logger;

import org.geotools.data.oracle.sdo.GeometryConverter;

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

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

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

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

import com.hardcode.gdbms.engine.data.file.FileSourceInfo;

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.DriverException;

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.drivers.DBLayerDefinition;

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

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

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

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

import com.iver.cit.gvsig.fmap.drivers.dbf.DBFDriver;

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

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

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.SelectableDataSource;

import com.iver.cit.gvsig.project.documents.table.ProjectTable;

import com.iver.cit.gvsig.project.documents.table.ProjectTableFactory;

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. Should work on Oracle Locator.

 * 

 * @author jldominguez

 *

 */

public class OracleSpatialDriver extends DefaultDBDriver implements

                ICanReproject, IWriteable {

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

        private OracleSpatialWriter writer = null;

        private static double FLATNESS = 0.8;

        private static int FETCH_SIZE = 15000;

        // utility object to convert geometries.

        private GeometryConverter geotools_conv;

        // switch variable

        private boolean use_geotools = false;

        // 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";

        private boolean tableHasSrid = true;

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

        private boolean isNotAvailableYet = true;

        private IGeometry nullGeom = new FNullGeometry();

        private Value nullVal = ValueFactory.createNullValue();

        private String nullSampleSqlCondition = "(ROWNUM = 1)";

        // private EmptyFeatureIterator emptyIt = new EmptyFeatureIterator();

        private IdLoaderThread idLoader;

//        private FLayer myLayer = null;

//        private TOC myTOC = null;

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

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

        public static final int ID_COLUMN_INDEX = 1;

        public static final String 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 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 MAX_ID_LENGTH = 30;

        private final static GeometryFactory geomFactory = new GeometryFactory();

        public static final double IRRELEVANT_DISTANCE = 0.00000001;

        private DriverAttributes drvAtts;

        private int[] pkOneBasedIndexes;

        private String[] fieldNames;

        private String not_restricted_sql = "";

        private Shape originalOracleWorkingArea;

        private STRUCT originalOracleWAStruct = 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 geoColName = "";

        private String oracleSRID;

        private String epsgSRID;

        private String destProj = "";

        private Rectangle2D fullExtent = null;

        private boolean emptyWhereClause = true;

        private boolean isGeogCS = false;

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

        private HashMap rowToId = new HashMap();

        private String standardSelectExpressionTrue = null;

        private String standardSelectExpressionFalse = null;

        public OracleSpatialDriver() {

                drvAtts = new DriverAttributes();

                drvAtts.setLoadedInMemory(false);

        }

        public void setData(Object[] params) {

                createOracleEpsgTable();

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

        }

        public void setData(Connection _conn, DBLayerDefinition lyrDef) {

                createOracleEpsgTable();

                conn = _conn;

                geotools_conv = new GeometryConverter((OracleConnection) conn);

                lyrDef.setConnection(conn);

                setLyrDef(lyrDef);

                geoColName = lyrDef.getFieldGeometry();

                not_restricted_sql =

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

                // various metadata settings

                // getMetaDataInThisThread();

                cleanWhereClause();

                loadSdoMetadata();

                oneRowMetadata();

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

                // PluginServices.getMDIManager().setWaitCursor();

                // String statustxt = PluginServices.getMainFrame().getStatusBar().getStatusText();

                setWAStruct();

                getMetadata();

                // PluginServices.getMainFrame().getStatusBar().setInfoText(statustxt);

                // PluginServices.getMDIManager().restoreCursor();

        }

        private void getMetadata() {

                setIdRowTable();

                if (cancelIDLoad) {

                        return;

                }

                originalOracleWorkingArea = getLyrDef().getWorkingArea();

                setWAStruct();

        }

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

                                if ((aux % 1000) != 3) {

                                        System.err.println("x");

                                }

                        }

                        _rs.close();

                        _st.close();

                        boolean resp = hasSeveralGeometryTypes(types, false);

                        return resp;

                } catch (Exception se) {

                        System.err.println("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 ASSUMED_ORACLE_SRID;

                }

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

                        /*

                        if (da.length != 2) {

                                throw new SQLException(

                                                "Expected a 2-dimensional array, found: " + da.length);

                        }

                        */

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

                                System.err

                                                .println("Error while getting full extent from metadata table.");

                                return null;

                                // fullExtentJTS = null;

                        }

                }

        }

        private void loadSdoMetadata() {

                try {

                        Statement _st = conn.createStatement();

                        String 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, conn);

                                epsgSRID = oracleSridToEpsgSrid(oracleSRID);

                                geoColName = _rs.getString("COLUMN_NAME");

                                fullExtent = getFullExtentFromCurrentRecord(_rs);

                                _rs.close();

                                _st.close();

                        } else {

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

                                                + qry);

                        }

                } catch (SQLException se) {

                        System.err.println("Error while getting SDO metadata: "

                                        + se.getMessage());

                }

        }

        /**

         * Utilitu 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.

         * @param _conn conenction object

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

         */

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

                if (! thas) {

                        return false;

                }

                int ora_cs = -10;

                try {

                        ora_cs = Integer.parseInt(oracleSRID2);

                } catch (Exception ex) {

                        return false;

                }

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

                        return true;

                }

                String _sql = "SELECT WKTEXT FROM CS_SRS WHERE SRID = " + ora_cs;

                try {

                        java.sql.PreparedStatement _ps = _conn.prepareStatement(_sql,

                                        ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY);

                        _ps.execute();

                        ResultSet _rs = _ps.getResultSet();

                        _rs.next();

                        String wkt = (String) _rs.getObject(1);

                        wkt = wkt.substring(0, 6);

                        _rs.close();

                        _ps.close();

                        return (wkt.compareToIgnoreCase("geogcs") == 0);

                } catch (Exception se) {

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

                }

                return false;

        }

        private Rectangle2D getFullExtentFromSample() {

                // numReg has a value

                if (numReg == 0) {

                        return null;

                } else {

                        return getBoundingFromSample(numReg);

                }

        }

        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 = conn.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();

                        // geoColInd = _rs.findColumn(geoColName);

                        oneBasedGeoColInd = metaData.getColumnCount() + 1;

                        DatabaseMetaData dbmd = conn.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() % 10;

                switch (code) {

                case 1:

                        return FShape.POINT;

                case 2:

                        return FShape.LINE;

                case 3:

                        return FShape.POLYGON;

                case 5:

                        return FShape.MULTIPOINT;

                case 6:

                        return FShape.LINE;

                case 7:

                        return FShape.POLYGON;

                }

                System.err.println("Unknown type");

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

        }

        public IFeatureIterator getFeatureIterator(String sql)

                        throws DriverException {

                if (isNotAvailableYet) {

                        return null;

                        // return emptyIt;

                }

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

        }

        public String getConnectionStringBeginning() {

                // oracle

                return CONN_STR_BEGIN;

        }

        static {

                try {

                        Class.forName("oracle.jdbc.driver.OracleDriver");

                } catch (ClassNotFoundException e) {

                        throw new RuntimeException(e);

                }

        }

        public void open() throws DriverException {

        }

        public int getDefaultPort() {

                // oracle port

                return 1521;

        }

        public IFeatureIterator getFeatureIterator(Rectangle2D r, String strEPSG)

                        throws DriverException {

                if (isNotAvailableYet) {

                        return null;

                }

                singleCachedFeatureRowNum = -1;

                Shape wa_and_view = intersectWorkingAreaAndView(r);

                if (wa_and_view == null) {

                        return null; //;

                }

                STRUCT local_st = shapeToStruct(wa_and_view, 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 Shape intersectWorkingAreaAndView(Rectangle2D r) {

                if (originalOracleWorkingArea == null) {

                        return r;

                }

                Rectangle2D res = null; // new Rectangle2D.Double();

                if (originalOracleWorkingArea instanceof Rectangle2D) {

                        res = doIntersect(r, (Rectangle2D) originalOracleWorkingArea);

                        // Rectangle2D.intersect(r, (Rectangle2D) originalOracleWorkingArea, res);

                } else {

                        // TODO

                        Rectangle2D aux = originalOracleWorkingArea.getBounds2D();

                        // res = r.createIntersection(aux);

                        res = doIntersect(r, aux);

                        // Rectangle2D.intersect(r, aux, res);

                }

                return res;

        }

        public IFeatureIterator getFeatureIterator(Rectangle2D r, String strEPSG,

                        String[] alphaNumericFieldsNeeded) throws DriverException {

                if (isNotAvailableYet) {

                        return null;

                        // return emptyIt;

                }

                singleCachedFeatureRowNum = -1;

                return getFeatureIterator(r, strEPSG);

        }

        public String getGeometryField(String fieldName) {

                return fieldName;

                // return "ASBINARY(" + fieldName + ")";

        }

        public DriverAttributes getDriverAttributes() {

                return drvAtts;

        }

        public IGeometry getShape(int _ind) throws IOException {

                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 = conn.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 IOException("SQLException: " + se.getMessage());

                }

        }

        public boolean isWritable() {

                return true;

        }

        public String getName() {

                return NAME;

        }

        public int[] getPrimaryKeys()

                        throws com.hardcode.gdbms.engine.data.driver.DriverException {

                return pkOneBasedIndexes;

        }

        public void write(DataWare dataWare)

                        throws com.hardcode.gdbms.engine.data.driver.DriverException {

        }

        private void setIdRowTable() {

                hashRelate = new Hashtable();

                java.sql.PreparedStatement ps = null;

                try {

                        String _sql = getIdAndElemInfoFullResulltSetQuery();

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

                        ps = conn.prepareStatement(_sql,

                                                ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY);

                        ps.setFetchDirection(ResultSet.FETCH_FORWARD);

                        ps.setFetchSize(FETCH_SIZE);

                        // ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY);

                        // _st.setFetchDirection(ResultSet.FETCH_FORWARD);

                        // _st.setFetchSize(200);

                        if (originalOracleWAStruct != null) {

                                ps.setObject(1, originalOracleWAStruct);

                        }

                        ps.execute();

                        ResultSet _r = ps.getResultSet();

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

                        numReg = row;

                        needsCollectionLayer = hasSeveralGeometryTypes(types, false);

                        if (needsCollectionLayer) {

                                shapeType = FShape.MULTI;

                        }

                } catch (SQLException e) {

                        System.err.println("While setting id-row hashmap: " + e.getMessage());

                }

        }

        public int getFieldCount()

                        throws com.hardcode.gdbms.engine.data.driver.DriverException {

                try {

                        return metaData.getColumnCount();

                } catch (SQLException e) {

                        System.err.println("While getting field count: " + e.getMessage());

                        throw new com.hardcode.gdbms.engine.data.driver.DriverException(e

                                        .getMessage());

                }

        }

        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 com.hardcode.gdbms.engine.data.driver.DriverException {

                int i = 0;

                try {

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

//                        if (i == 0) {

//                                return Types.VARCHAR;

//                        }

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

                        System.err.println("i = " + i);

                        throw new com.hardcode.gdbms.engine.data.driver.DriverException(e);

                }

                return -1;

        }

        public Value[] getAttributes(ResultSet rs) {

                Value[] res = null;

                try {

                        int fcount = rs.getMetaData().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();

                                                        _type = getFieldType(i);

                                                }

                                        }

                                }

                                // /*

                                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 (SQLException se) {

                        System.err.println("Error while getting attributes: "

                                        + se.getMessage());

                        return null;

                } catch (com.hardcode.gdbms.engine.data.driver.DriverException e) {

                        System.err.println("Error while getting attributes: "

                                        + e.getMessage());

                        return null;

                } catch (ParseException e) {

                        System.err.println("Error while getting attributes: "

                                        + e.getMessage());

                        return null;

                }

                return res;

        }

        public String getFieldName(int fieldId)

                        throws com.hardcode.gdbms.engine.data.driver.DriverException {

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

                        System.err.println("While getting field width: " + e.getMessage());

                }

                // SUN define que getColumnDisplaySize devuelve numeros negativos cuando el campo es de tipo Text o Vartext

                // sin ancho. Nosotros vamos a devolver 255 para que fucione, por lo menos al exportar a DBF.

                // Nota: Si se truncan cadenas, este es el sitio que lo provoca.

                if (i < 0)

                        i = 255;

                return i;

        }

        public Value getFieldValue(long rowIndex, int field_Id)

                        throws com.hardcode.gdbms.engine.data.driver.DriverException {

                if (isNotAvailableYet) {

                        return nullVal;

                }

                // if it is cached, return the value 

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

                        // String rnq = getSearchRowNumQuery((int) rowIndex);

                        ps = conn.prepareStatement(rnq);

                        // if (originalOracleWAStruct != null) {

                        ps.setObject(1, _id);

                        // }

                        ps.execute();

                        _r = ps.getResultSet();

                        _r.next();

                } catch (SQLException se) {

                        throw new com.hardcode.gdbms.engine.data.driver.DriverException(se

                                        .getMessage());

                }

                IFeature ife = null;

                Value[] atts = null;

                try {

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

                        atts = getAttributes(_r);

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

                }

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

                singleCachedFeature = ife;

                singleCachedFeatureRowNum = rowIndex;

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

                if (atts == null) {

                        return ValueFactory.createNullValue();

                } else {

                        return atts[field_Id];

                }

        }

        public static void showMemory() {

                Runtime r = Runtime.getRuntime();

                long mem = r.totalMemory() - r.freeMemory();

                System.err.println("Memoria total: " + mem);

        }

        public Rectangle2D getFullExtent() {

                // SELECT SDO_AGGR_MBR(GEOMETRY1) FROM HOJAS_25000 WHERE

                return fullExtent;

        }

        public IGeometry getGeometryUsing(STRUCT theStruct, boolean use_gtools)

                        throws SQLException {

                IGeometry _igeom = null;

                if (theStruct == null) {

                        return nullGeom;

                }

                if (use_gtools) { // geotools

                        _igeom = getGeotoolsIGeometry(theStruct);

                } else { // jgeometry

                        // System.err.println(System.currentTimeMillis());

                        // JGeometry j_geom = JGeometry.load(theStruct);

                        // _igeom = getFMapGeometry(j_geom, false);

                        _igeom = getFMapGeometry(theStruct, false);

                        // System.err.println(System.currentTimeMillis());

                }

                return _igeom;

        }

        private IGeometry getFMapGeometry(JGeometry jg, boolean force_not_collection) {

                int jgtype = jg.getType();

                int dim = jg.getDimensions();

                IGeometry ig = null; 

                if ((jgtype != JGeometry.GTYPE_COLLECTION) && (isActuallyACollection(jg))) {

                        jgtype = JGeometry.GTYPE_COLLECTION;

                }

                switch (jgtype) {

                case JGeometry.GTYPE_COLLECTION:

                        int srid = jg.getSRID();

                        ig = getFMapGeometryCollection(jg, dim, srid);

                        break;

                case JGeometry.GTYPE_POINT:

                case JGeometry.GTYPE_MULTIPOINT:

                        ig = getFMapGeometryPoint(jg, dim);

                        break;

                case JGeometry.GTYPE_CURVE:

                case JGeometry.GTYPE_MULTICURVE:

                        ig = getFMapGeometryMultiLineString(jg, dim);

                        break;

                case JGeometry.GTYPE_POLYGON:

                case JGeometry.GTYPE_MULTIPOLYGON:

                        ig = getFMapGeometryMultipolygon(jg, dim);

                        break;

                }

                return ig;

        }

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

//                Connection conn = null;

//                

//                try {

//                        conn = st.getOracleConnection();

//                } catch (SQLException se) {

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

//                }

                NUMBER main_type = new NUMBER(dim * 1000 + OracleSpatialUtils.getStructType(the_data));

                NUMBER _srid = new NUMBER(__srid);

                Datum[] all_info_array = null;

                Object[] elems_info_aray = null;

                Datum[] all_ords = null;

                        try {

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

                                // iadesc = ((ARRAY) st.getOracleAttributes()[3]).getDescriptor();

                                elems_info_aray = groupByElement(all_info_array);

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

                                // oadesc = ((ARRAY) st.getOracleAttributes()[4]).getDescriptor();

                        } catch (SQLException e) {

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

                        }

                Object[] ords_of_groups = getOrdOfGroups(all_ords, elems_info_aray);

                Object[] _elems_info_aray = new Object[elems_info_aray.length];

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

                        _elems_info_aray[i] = 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);

                        } catch (SQLException se) {

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

                        }

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

                        if (i==0) {

                                gtype = main_type;

                        }

                        STRUCT itemst = null;

                        if (tableHasSrid) {

                                itemst = OracleSpatialUtils.createStruct(

                                                gtype, _srid, item_info_array, item_ords, conn);

                        } else {

                                itemst = OracleSpatialUtils.createStruct(

                                                gtype, null, item_info_array, item_ords, conn);

                        }

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

                }

                return new FGeometryCollection(geoms);

        }

        public IGeometry getFMapGeometry(STRUCT st, boolean force_not_collection) {

                // FJP: Esto es para evitar hacer esta llamada varias veces,

                // que consume bastante tiempo.

                Datum[] the_data = null;

                try

                {

                        the_data = st.getOracleAttributes();

                        // Evitamos getOracleAttributes

                        // int jgtype = OracleSpatialUtils.getStructType(st);

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

                        jgtype = OracleSpatialUtils.oracleGTypeToFShapeType(jgtype);

                        // int dim = OracleSpatialUtils.getStructDimensions(st);

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

                        if (dim < 2) dim = 2; 

                        IGeometry ig = null; 

                        if (isActuallyACollection(the_data)) {

                                jgtype = FShape.MULTI;

                        }

                        switch (jgtype) {

                        case FShape.MULTI:

                                // idem

                                // int srid = OracleSpatialUtils.getStructSRID(st);

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

                                ig = getFMapGeometryCollection(the_data, dim, srid);

                                break;

                        case FShape.POINT:

                                ig = getFMapGeometryPoint(the_data, dim);

                                break;

                        case FShape.LINE:

                                ig = getFMapGeometryMultiLineString(the_data, dim);

                                break;

                        case FShape.POLYGON:

                                ig = getFMapGeometryMultipolygon(the_data, dim);

                                break;

                        }

                        return ig;                        

                }

                catch (SQLException e)

                {

                        logger.error(e);                        

                }

                return null;

        }