Application: gvSIG desktop

		// return true;

		return false;

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

import org.gvsig.oracle.extension.ExportToOracle;

		return result.booleanValue();

	}

	public void addWithEnvelopeAndDims(NewFeatureStoreParameters params, boolean b,

			Rectangle2D envelope, int thedims) throws DataException {

		String sql_create = add_SqlCreate(params, b);

		String sql_index = add_SqlIndex(params, b);

		String sql_meta = add_SqlMeta(params, b, envelope, new Integer(thedims));

		doAdd(sql_create, sql_index, sql_meta);

	}

	private boolean doAdd(final String sql_create, final String sql_index, final String sql_meta) {

					sqlnew = sql_create;

					sqlmetadata = sql_meta;

					sqlspatialindex = sql_index;

	private String add_SqlMeta(NewFeatureStoreParameters params, boolean b,

			Rectangle2D bbox, Integer thedims) {

		// SQL CREATE TABLE METADATA

		Rectangle2D _bbox = bbox;

		if (_bbox == null) {

			logger.warn("Envelope not found in parameters: set (0,0) - (1,1)");

			_bbox = OracleUtils.DEFAULT_BBOX;

		}

		int _dims = 2;

		if (thedims == null) {

			logger.warn("Dimensions not found in parameters: assumed 2");

		} else {

			_dims = thedims.intValue();

		}

		String sqlmeta = ((OracleHelper) helper).getSqlUpdateMetadata(

				(OracleStoreParameters) params, null, _bbox, _dims, true);

		// TODO Auto-generated method stub

		return sqlmeta;

	}

	private String add_SqlIndex(NewFeatureStoreParameters params, boolean b) {

		// SQL CREATE SPATIAL INDEX

		String sqlindex = "CREATE INDEX "

				+ OracleUtils.getDerivedName(((JDBCStoreParameters) params)

						.tableID(), "SX") + " ON "

				+ ((JDBCStoreParameters) params).tableID() + " (\""

				+ OracleValues.DEFAULT_GEO_FIELD

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

		return sqlindex;

	}

	private String add_SqlCreate(NewFeatureStoreParameters nfdsp, boolean b) throws DataException {

		// SQL CREATE NEW TABLE

		StringBuilder sqlnewtable = new StringBuilder();

		FeatureType fType = nfdsp.getDefaultFeatureType();

		sqlnewtable.append("CREATE TABLE "

				+ ((JDBCStoreParameters) nfdsp).tableID() + "(");

		Iterator<FeatureAttributeDescriptor> attrs = fType.iterator();

		String sqlAttr;

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

		while (attrs.hasNext()) {

			sqlAttr = helper

					.getSqlFieldDescription((FeatureAttributeDescriptor) attrs

							.next());

			if (sqlAttr != null) {

				sqlAttrs.add(sqlAttr);

			}

		}

		helper.stringJoin(sqlAttrs, ", ", sqlnewtable);

		String pk = "CONSTRAINT "

				+ OracleUtils.getDerivedName(((JDBCStoreParameters) nfdsp)

						.tableID(), "PK") + " PRIMARY KEY (\""

				+ OracleValues.DEFAULT_ID_FIELD_CASE_SENSITIVE + "\") ENABLE";

		sqlnewtable.append(", ");

		sqlnewtable.append(pk);

		sqlnewtable.append(")");

		return sqlnewtable.toString();		

	}

	 * create new table

	 * 

	 * @params ndsp

	 * @params overwrite

	 * @return

	 */

	public boolean add(NewDataStoreParameters ndsp, boolean overwrite)

			throws DataException {

		if (!(ndsp instanceof NewFeatureStoreParameters)) {

			throw new IllegalArgumentException("Expected: NewFeatureStoreParameters");

		}

		checkIsMine(ndsp);

		NewFeatureStoreParameters nfdsp = (NewFeatureStoreParameters) ndsp;

		if (!nfdsp.isValid()) {

			throw new InitializeException(this.getName(), new Exception(

					"Parameters not valid"));

		}

		try {

			nfdsp.validate();

		} catch (ValidateDataParametersException e1) {

			throw new InitializeException(this.getName(), e1);

		}

		String sql_create = add_SqlCreate(nfdsp, overwrite);

		String sql_index = add_SqlIndex(nfdsp, overwrite);

		String sql_meta = add_SqlMeta(nfdsp, overwrite, null, null);

		return doAdd(sql_create, sql_index, sql_meta);

	}

	/**

import java.sql.ResultSet;

import java.sql.SQLException;

import org.cresques.cts.IProjection;

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

import org.gvsig.tools.exception.BaseException;

		} else {

			throw new RuntimeException("Not implemented: fixFilter in OracleStoreProvider. Input was: " + filter);

	protected void loadFeatureProviderValue(FeatureProvider data, ResultSet rs,

			FeatureAttributeDescriptor attr) throws DataException {

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

			try {

				Object geo_str_obj = rs.getObject(attr.getIndex() + 1);

				if (geo_str_obj == null) {

					data.set(attr.getIndex(), null);

				} else {

					STRUCT geo_str = (STRUCT) geo_str_obj;

					IProjection proj = attr.getSRS();

					// OracleUtils.

					Geometry geom = OracleUtils.getGeometry(

							geo_str,

							false,

							true,

							"88888",

							helper.getConnection());

					data.set(attr.getIndex(), geom);

				}

			} catch (SQLException e) {

				throw new JDBCSQLException(e);

			} catch (BaseException e) {

				throw new ReadException(getName(), e);

			}

		} else {

			try {

				data.set(attr.getIndex(), rs.getObject(attr.getIndex() + 1));

			} catch (SQLException e) {

				throw new JDBCSQLException(e);

			}

		}

	}

import java.util.Arrays;

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

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

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

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

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

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

	private static final double ORACLE_SPATIAL_DEFAULT_TOLERANCE = 0.0005;

	private static final String IDENTIFIER_QUOTE_STRING = "\"";

		/*

		*/

	protected String getIdentifierQuoteString() {

		return IDENTIFIER_QUOTE_STRING;

	}

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

			OracleNewStoreParameters osp = (OracleNewStoreParameters) storeParams;

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

			storeParams.setDefaultGeometry(geoname);

		}

		storeParams.setSQL(null);

		String reserved_geocolname = null;

			ArrayList geoAttrs = new ArrayList();

			EditableFeatureAttributeDescriptor auxdesc;

					String rsName =

						rs.getString(OracleValues.USER_ORACLE_GEOMETADATA_VIEW_COLUMN_NAME);

					reserved_geocolname = rsName;

					auxdesc = getAttrDescForCol(geoAttrs, rsName);

					if (auxdesc != null) {

							auxdesc.setSRS(null);

							int epsg = OracleUtils.oracleSridToEpsg(srID);

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

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

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

					}

			}

		} catch (java.sql.SQLException e) {

			throw new JDBCSQLException(e);

		} finally {

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

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

		}

		// guess shape type

		String geoColName = featureType.getDefaultGeometryAttributeName();

		if (geoColName == null) {

			geoColName = reserved_geocolname; 

		}

		try {

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

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

			st = conn.createStatement();

			try {

				rs = st.executeQuery(str_geo);

			} catch (SQLException e) {

				throw new JDBCExecuteSQLException(str_geo, e);

            int aux = 0;

            int guess_type = TYPES.GEOMETRY;

            int guess_subtype = SUBTYPES.GEOM2D;

            STRUCT sample_geo;

            ArrayList shptypes = new ArrayList();

            int[] ty_subty;

            while (rs.next()) {

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

                ty_subty = OracleUtils.getGeoTypeSubTypeOfStruct(sample_geo); 

                aux = ty_subty[0];

                guess_subtype = ty_subty[1];

                shptypes.add(new Integer(aux));

            }

            if (shptypes.size() > 0) {

            	guess_type = OracleUtils.getShapeTypeFromArray(shptypes);

            } else {

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

            }

            DefaultEditableFeatureAttributeDescriptor dfad = null;

            try {

                dfad = (DefaultEditableFeatureAttributeDescriptor) featureType.getDefaultGeometryAttribute();

                dfad.setGeometryType(guess_type);

                dfad.setGeometrySubType(guess_subtype);

            } catch (ClassCastException cce) {

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

            }

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

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

		}

	}

	private EditableFeatureAttributeDescriptor getAttrDescForCol(ArrayList list, String name) {

		int sz = list.size();

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

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

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

				return aux;

		// not found

		return null;

//	protected void loadFeatureType(Connection conn,

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

//			String defGeomName, String schema, String table)

//			throws DataException {

//

//		Statement stAux = null;

//		ResultSet rs = null;

//		try {

//

//			stAux = conn.createStatement();

//			stAux.setFetchSize(1);

//

//			try {

//				rs = stAux.executeQuery(sql);

//			} catch (SQLException e) {

//				throw new JDBCExecuteSQLException(sql, e);

//			}

//			ResultSetMetaData rsMetadata = rs.getMetaData();

//

//			List pksList = null;

//			if (pks != null) {

//				pksList = Arrays.asList(pks);

//			}

//

//			int i;

//			int geometriesColumns = 0;

//			String lastGeometry = null;

//

//			EditableFeatureAttributeDescriptor attr;

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

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

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

//					attr.setIsPrimaryKey(true);

//				}

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

//					geometriesColumns++;

//					lastGeometry = attr.getName();

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

//						featureType.setDefaultGeometryAttributeName(defGeomName);

//					}

//				}

//			}

//

//			if (geometriesColumns > 0) {

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

//						table);

//			}

//

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

//				featureType.setDefaultGeometryAttributeName(lastGeometry);

//				defGeomName = lastGeometry;

//			}

//

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

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

//		} finally {

//			try {

//				rs.close();

//			} catch (Exception e) {

//			}

//			try {

//				stAux.close();

//			} catch (Exception e) {

//			}

//

//		}

//

//	}

import org.cresques.cts.IProjection;

import org.geotools.xml.filter.FilterOpsComplexTypes.UpperBoundaryType;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

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

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

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

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

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

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

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

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

import org.gvsig.fmap.geom.aggregate.MultiPrimitive;

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

	public static final Rectangle2D DEFAULT_BBOX = new Rectangle2D.Double(-180, -90, 360, 180);;

	public static final String ENVELOPE_ID = "Envelope_Key";

	public static final String DIMENSIONS_ID = "Dimensions_Key";

				resp = Geometry.TYPES.AGGREGATE;

	 * @param sample input STRUCT

	 * @return type and subtype of geometry

	public static int[] getGeoTypeSubTypeOfStruct(STRUCT sample) throws SQLException {

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

		return getGeoTypeSubTypeOfOracleCode(_code);

	}

	public static int[] getGeoTypeSubTypeOfOracleCode(int code) {

		// [TYPES.?, SUBTYPES.?]

		int[] resp = new int[2];

		resp[1] = SUBTYPES.GEOM2D;

			resp[1] = SUBTYPES.GEOM3D;

				resp[1] = SUBTYPES.GEOM3DM;

		resp[0] = TYPES.GEOMETRY;

			resp[0] = Geometry.TYPES.POINT;

			break;

			resp[0] = Geometry.TYPES.CURVE;

			break;

			resp[0] = Geometry.TYPES.SURFACE;

			break;

			resp[0] = Geometry.TYPES.AGGREGATE;

			break;

			resp[0] = Geometry.TYPES.MULTIPOINT;

			break;

			resp[0] = Geometry.TYPES.CURVE;

			break;

			resp[0] = Geometry.TYPES.SURFACE;

			break;

		default:

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

		break;

		return resp;

	public static int getShapeTypeFromArray(ArrayList arrlist) {

		int resp = ((Integer) arrlist.get(0)).intValue();

		int sz = arrlist.size();

		int aux = 0;

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

			aux = ((Integer) arrlist.get(i)).intValue();

			if (aux != resp) return TYPES.GEOMETRY;

		}

		return resp;

	}

	// condition using ROWNUM with growing indexs to do a size-independent sample

    public static String EXPONENTIAL_INDICES_CONDITION = null;

    static {

    	String sb = "";

    	int i=0;

    	sb = "(rownum = 1)";

    	for (i=2; i<20; i++) {

    		sb = "(" + sb + " OR (rownum = " + i + "))";

    	}

    	int cnt = 0;

    	float aux = 1;

    	while (cnt < 35) {

    		aux = aux * 1.5f;

    		i = 20 + Math.round(aux);

    		sb = "(" + sb + " OR (rownum = " + i + "))";

    		cnt++;

    	}

		aux = aux * 1.5f;

		i = 20 + Math.round(aux);

		sb = "(" + sb + " OR (rownum = " + i + "))";

		EXPONENTIAL_INDICES_CONDITION = sb;

    }

	public static void copyFeatureTypeToOracleStoreParams(

			EditableFeatureType efType, OracleStoreParameters params) {

		// TODO Auto-generated method stub

	}

    /**

     * Utility method to transform a struct into a IGeometry.

     *

     * @param st the struct to be converted

     * @param complex comes from a complex sdo geometry

     * @return the IGeometry

     */

    public static Geometry getGeometry(

    		STRUCT st,

    		boolean complex,

    		boolean __tablehassrid,

    		String __tablesrid,

    		Connection _conn) {

    	GeometryManager gm = GeometryLocator.getGeometryManager();

    	if (st == null) {

    		Geometry aux = null;

    		try {

				aux = gm.createNullGeometry(SUBTYPES.GEOM2D);

			} catch (CreateGeometryException e) {

				logger.error("While creating null Geometry: " + e.getMessage());

			}

    		return aux;

    	}

        Datum[] the_data = null;

        try {

            the_data = st.getOracleAttributes();

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

            jgtype = oracleGTypeToFShapeType(jgtype, complex);

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

            if (dim < 2) {

                dim = 2;

            }

            int subty = getSubTypeFromDims(dim);

            Geometry ig = gm.createNullGeometry(subty);

            if (isActuallyACollection(the_data)) {

                jgtype = TYPES.AGGREGATE;

            }

            switch (jgtype) {

            case TYPES.AGGREGATE:

                ig = getFMapGeometryCollection(the_data, dim, __tablehassrid, __tablesrid, _conn);

                break;

            case TYPES.POINT:

                ig = getFMapGeometryPoint(the_data, dim);

                break;

            case TYPES.CURVE:

                ig = getFMapGeometryMultiLineString(the_data, dim);

                break;

            case TYPES.SURFACE:

                ig = getFMapGeometryMultipolygon(the_data, dim);

                break;

            }

            return ig;

        } catch (Exception e) {

            logger.error("While creating Geometry from STRUCT: " + e.getMessage());

        }

        return null;

    }

    /**

     * Utility method to transform a struct into a IGeometry.

     *

     * @param st the struct to be converted

     * @param complex comes from a complex sdo geometry

     * @return the IGeometry

     */

    public static Primitive getPrimitive(STRUCT st, boolean complex) {

    	GeometryManager gm = GeometryLocator.getGeometryManager();

    	Primitive resp = null;

    	if (st == null) {

    		try {

				resp = gm.createNullGeometry(SUBTYPES.GEOM2D);

			} catch (CreateGeometryException e) {

				logger.error("While creating null geometry: " + e.getMessage());

			}

			return resp;

    	}

        Datum[] the_data = null;

        try {

            the_data = st.getOracleAttributes();

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

            jgtype = oracleGTypeToFShapeType(jgtype, complex);

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

            if (dim < 2) {

                dim = 2;

            }

        	int subty = getSubTypeFromDims(dim);

        	Primitive ig = null;

        	try {

				ig = gm.createNullGeometry(subty);

			} catch (CreateGeometryException e) {

				logger.error("While creating null geometry: " + e.getMessage());

			}

            if (isActuallyACollection(the_data)) {

                jgtype = TYPES.AGGREGATE;

            }

            try {

                switch (jgtype) {

                case TYPES.POINT:

                    ig = (Primitive) getFMapGeometryPoint(the_data, dim);

                    break;

                case TYPES.CURVE:

                    ig = (Primitive) getFMapGeometryMultiLineString(the_data, dim);

                    break;

                case TYPES.SURFACE:

                    ig = (Primitive) getFMapGeometryMultipolygon(the_data, dim);

                    break;

                default:

                	logger.error("Aggregate of non primitives not supported.");

                    break;

                }

            } catch (Exception ex) {

            	logger.error("While creating primitive: " + ex.getMessage());

            }

            return ig;

        } catch (SQLException e) {

            logger.error(e);

        }

        return null;

    }

    private static int getSubTypeFromDims(int dim) {

    	switch (dim) {

    	case 3:

    		return SUBTYPES.GEOM3D;

    	case 4:

    		return SUBTYPES.GEOM3DM;

    	default:

    			return SUBTYPES.GEOM2D;

    	}

	}

	public static Geometry getFMapGeometryCollection(

    		Datum[] the_data,

    		int dim,

    		boolean tableHasSrid,

    		String table_srid,

    		Connection _conn) {

    	NUMBER _srid = new NUMBER(0);

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

        Datum[] all_info_array = null;

        Object[] elems_info_aray = null;

        Datum[] all_ords = null;

        Object[] ords_of_groups = null;

        Object[] _elems_info_aray = null;

        try {

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

            elems_info_aray = groupByElement(all_info_array);

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

            ords_of_groups = getOrdOfGroups(all_ords, elems_info_aray);

            _elems_info_aray = new Object[elems_info_aray.length];

        }

        catch (SQLException e) {

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

        }

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

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

        }

        // _elems_info_aray, ords_of_groups

        int no_of_elems = ords_of_groups.length;

        Primitive[] geoms = new Primitive[no_of_elems];

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

            Datum[] item_info_array = null;

            Datum[] item_ords = null;

            NUMBER gtype = null;

            try {

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

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

                gtype = new NUMBER((dim * 1000) +

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

                if (tableHasSrid) {

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

                }

            }

            catch (SQLException se) {

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

            }

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

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

            STRUCT itemst = null;

            if (tableHasSrid) {

                itemst = createStruct(gtype, _srid,

                        item_info_array, item_ords, _conn);

            }

            else {

                itemst = createStruct(gtype, null,

                        item_info_array, item_ords, _conn);

            }

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

        }

    	GeometryManager gm = GeometryLocator.getGeometryManager();

    	int subt = getSubTypeFromDims(dim);

        MultiPrimitive resp = null;

        try {

			resp = (MultiPrimitive) gm.create(TYPES.AGGREGATE, subt);

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

	        	resp.addPrimitive(geoms[i]);

	        }

		} catch (Exception e) {

			logger.error("While creating multi primitive: " + e.getMessage());

		}

        return resp;

    }

	// ===========================================================

	/**

	 * Get oracle srid from srs code(EPSG code)

	 * 

	 * @param epsg

	 * @return oraSRID

	 */

	public static String epsgToOracleSrid(String epsg) {

		DataManager manager = DALLocator.getDataManager();

		int isrs = -1;

		if (epsg != null) {

			FeatureStore oraSrsStore = (FeatureStore) OracleLibrary

					.getSRSDataStore();

			FeatureSet set = null;

			try {

				FeatureQuery query = oraSrsStore.createFeatureQuery();

				query.setFilter(manager.createExpresion("EPSG = " + epsg));

				set = (FeatureSet) oraSrsStore.getDataSet(query);

				if (set.getSize() > 0) {

					Iterator<Feature> it = set.iterator();

					while (it.hasNext()) {

						Feature feat = it.next();

						Double ora = feat.getDouble("ORACLE");

						int iora = ora.intValue();

						double prefe = feat.getDouble("PRF_ORACLE");

						if (prefe == 1) {

							isrs = iora;

							break;

						}

					}

				}

			} catch (DataException e) {

				e.printStackTrace();

			}

			if (isrs >= 0) {

				return Integer.toString(isrs);

			}

		}

		return null;

	}

	/**

	 * Get EPSG SRS from Oracle SRS

	 * 

	 * @param oraSRID

	 * @return

	 */

	public static Integer oracleSridToEpsg(String oraSRID) {

		DataManager manager = DALLocator.getDataManager();

		Integer isrs = null;

		if (oraSRID != null) {

			FeatureStore oraSrsStore = (FeatureStore) OracleLibrary

					.getSRSDataStore();

			FeatureSet set = null;

			try {

				FeatureQuery query = oraSrsStore.createFeatureQuery();

				query.setFilter(manager.createExpresion("ORACLE = " + oraSRID));

				set = (FeatureSet) oraSrsStore.getDataSet(query);

				if (set.getSize() > 0) {

					Iterator<Feature> it = set.iterator();

					while (it.hasNext()) {

						Feature feat = it.next();

						isrs = new Integer(feat.getInt("EPSG"));

					}

				}

			} catch (DataException e) {

				logger.error("While getting EPSG from oracle srid: " + e.getMessage());

			}

			return isrs;

		} else {

			return null;

		}

	}

	/**

	 * Get Oracle SRS from gvSIG projection

	 * 

	 * @param proj

	 * @return  

	 */

	public static String projectionToOracleSrid(IProjection proj) {

		if (proj != null) {

			String epsg = proj.getAbrev().trim();

			int ocu = epsg.indexOf(":");

			if (ocu != -1) {

				epsg = epsg.substring(ocu + 1);

			}

			return epsgToOracleSrid(epsg);

		} else {

			return null;

		}

	}

	public static int dimensionsFromSubtype(int subtype) {

		switch (subtype) {

		case SUBTYPES.GEOM2D:

			return 2;

		case SUBTYPES.GEOM3D:

		case SUBTYPES.GEOM2DZ:

		case SUBTYPES.GEOM2DM:

			return 3;

		case SUBTYPES.GEOM3DM:

			return 4;

		default:

				logger.error("Unknown subtype: " + subtype + ". Returned 2 as number of dimensions.");

			return 2;

		}

	}

	public static Rectangle2D envelopeToRectangle2D(org.gvsig.fmap.geom.primitive.Envelope envelope) {

		double x = envelope.getMinimum(0);

		double y = envelope.getMinimum(1);

		double w = envelope.getLength(0);