Application: gvSIG desktop

/* gvSIG. Geographic Information System of the Valencian Government

 *

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

 * of the Valencian Government (CIT)

 *

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

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

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

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

 *

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

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

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

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

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

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

 * MA  02110-1301, USA.

 *

 */

/*

 * AUTHORS (In addition to CIT):

 * 2009 Prodevelop S.L. main development

 */

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

import java.util.ArrayList;

import java.util.List;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

import oracle.sql.STRUCT;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataServerExplorer;

import org.gvsig.fmap.dal.DataTypes;

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

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

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

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

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

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

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

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

import org.gvsig.fmap.dal.feature.spi.FeatureProvider;

import org.gvsig.fmap.dal.feature.spi.FeatureSetProvider;

import org.gvsig.fmap.dal.spi.DataStoreProviderServices;

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

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

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynClass;

import org.gvsig.tools.dynobject.DynObjectManager;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * Oracle Provider

 * 

 * @author vsanjaime

 * 

 */

public class OracleStoreProvider extends JDBCStoreProviderWriter {

        public final static Logger logger = LoggerFactory

                        .getLogger(OracleStoreProvider.class);

        public static String NAME = "OracleSpatial";

        public static String DESCRIPTION = "Oracle source";

        private static final String DYNCLASS_NAME = "OracleStore";

        private static DynClass DYNCLASS = null;

        protected static void registerDynClass() {

                DynObjectManager dynman = ToolsLocator.getDynObjectManager();

                DynClass dynClass;

                if (DYNCLASS == null) {

                        dynClass = dynman.add(DYNCLASS_NAME, DESCRIPTION);

                        dynClass.extend(dynman.get(FeatureStore.DYNCLASS_NAME));

                        DYNCLASS = dynClass;

                }

        }

        public OracleStoreProvider(OracleStoreParameters params,

                        DataStoreProviderServices storeServices) throws InitializeException {

                super(params, storeServices, ToolsLocator.getDynObjectManager()

                                .createDynObject(DYNCLASS));

        }

        private OracleStoreParameters getOracleStoreParameters() {

                return (OracleStoreParameters) this.getParameters();

        }

        protected JDBCHelper createHelper() throws InitializeException {

                return new OracleHelper(this, getOracleStoreParameters());

        }

        protected String fixFilter(String filter) {

                if (filter == null) {

                        return null;

                }

                // Transform SRS to code

                // GeomFromText\s*\(\s*'[^']*'\s*,\s*('[^']*')\s*\)

                Pattern pattern = Pattern

                                .compile("GeomFromText\\s*\\(\\s*'[^']*'\\s*,\\s*'([^']*)'\\s*\\)");

                Matcher matcher = pattern.matcher(filter);

                StringBuilder strb = new StringBuilder();

                int pos = 0;

                String srsCode;

                while (matcher.find(pos)) {

                        strb.append(filter.substring(pos, matcher.start(1)));

                        srsCode = matcher.group(1).trim();

                        if (srsCode.startsWith("'")) {

                                srsCode = srsCode.substring(1);

                        }

                        if (srsCode.endsWith("'")) {

                                srsCode = srsCode.substring(0, srsCode.length() - 1);

                        }

                        strb.append(helper.getProviderSRID(srsCode));

                        strb.append(filter.substring(matcher.end(1), matcher.end()));

                        pos = matcher.end();

                }

                strb.append(filter.substring(pos));

                return strb.toString();

        }

        public String getName() {

                return NAME;

        }

        public FeatureSetProvider createSet(FeatureQuery query,

                        FeatureType featureType) throws DataException {

                return new OracleSetProvider(this, query, featureType);

        }

        public DataServerExplorer getExplorer() throws ReadException {

                DataManager manager = DALLocator.getDataManager();

                OracleServerExplorerParameters exParams;

                OracleStoreParameters params = getOracleStoreParameters();

                try {

                        exParams = (OracleServerExplorerParameters) manager

                                        .createServerExplorerParameters(OracleServerExplorer.NAME);

                        exParams.setUrl(params.getUrl());

                        exParams.setHost(params.getHost());

                        exParams.setPort(params.getPort());

                        exParams.setDBName(params.getDBName());

                        exParams.setUser(params.getUser());

                        exParams.setPassword(params.getPassword());

                        exParams.setCatalog(params.getCatalog());

                        exParams.setSchema(params.getSchema());

                        exParams.setJDBCDriverClassName(params.getJDBCDriverClassName());

                        exParams.setUseSSL(params.getUseSSL());

                        exParams.setOraDriverType(params.getOraDriverType());

                        return manager.createServerExplorer(exParams);

                } catch (DataException e) {

                        throw new ReadException(this.getName(), e);

                } catch (ValidateDataParametersException e) {

                        throw new ReadException(this.getName(), e);

                }

        }

        public boolean allowAutomaticValues() {

                return true;

        }

        public boolean hasGeometrySupport() {

                return true;

        }

        protected OracleHelper getOraHelper() {

                return (OracleHelper) getHelper();

        }

        public boolean canWriteGeometry(int geometryType, int geometrySubtype)

                        throws DataException {

                FeatureType type = getFeatureStore().getDefaultFeatureType();

                FeatureAttributeDescriptor geomAttr = type.getAttributeDescriptor(type

                                .getDefaultGeometryAttributeName());

                if (geomAttr == null) {

                        return false;

                }

                if (geometrySubtype != geomAttr.getGeometrySubType()) {

                        return false;

                }

                switch (geomAttr.getGeometryType()) {

                case Geometry.TYPES.GEOMETRY:

                        return true;

                case Geometry.TYPES.MULTISURFACE:

                        return geometryType == Geometry.TYPES.MULTISURFACE;

                case Geometry.TYPES.MULTIPOINT:

                        return geometryType == Geometry.TYPES.MULTIPOINT;

                case Geometry.TYPES.MULTICURVE:

                        return geometryType == Geometry.TYPES.MULTICURVE;

                case Geometry.TYPES.MULTISOLID:

                        return geometryType == Geometry.TYPES.MULTISOLID;

                case Geometry.TYPES.SURFACE:

                        return geometryType == Geometry.TYPES.SURFACE;

                case Geometry.TYPES.POINT:

                        return geometryType == Geometry.TYPES.POINT;

                case Geometry.TYPES.CURVE:

                        return geometryType == Geometry.TYPES.CURVE;

                case Geometry.TYPES.SOLID:

                        return geometryType == Geometry.TYPES.SOLID;

                default:

                        return geometryType == geomAttr.getGeometryType();

                }

        }

        protected void addToListFeatureValues(FeatureProvider featureProvider,

                        FeatureAttributeDescriptor attrOfList,

                        FeatureAttributeDescriptor attr, List values) throws DataException {

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

                        Geometry geom = (Geometry) featureProvider.get(attr.getIndex());

                        STRUCT stru = OracleUtils.GeometryToSTRUCT(geom, c, srid, agu_b,

                                        hasSrid);

                        values.add(stru);

                } else {

                        super.addToListFeatureValues(featureProvider, attrOfList, attr,

                                        values);

                }

        }

        protected String getSqlStatementAddField(FeatureAttributeDescriptor attr,

                        List additionalStatement) throws DataException {

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

                        OracleStoreParameters params = getOracleStoreParameters();

                        additionalStatement.add(((OracleHelper) helper)

                                        .getSqlGeometryFieldAdd(attr, params.getTable(), params

                                                        .getSchema()));

                }

                return super.getSqlStatementAddField(attr, additionalStatement);

        }

        protected String getSqlStatementDropField(FeatureAttributeDescriptor attr,

                        List additionalStatement) {

                String result = super.getSqlStatementDropField(attr,

                                additionalStatement);

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

                        additionalStatement.add(getSqlGeometryFieldDrop(attr));

                }

                return result;

        }

        protected List<String> getSqlStatementAlterField(

                        FeatureAttributeDescriptor attrOrg,

                        FeatureAttributeDescriptor attrTrg, List additionalStatement)

                        throws DataException {

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

                StringBuilder strb;

                OracleStoreParameters params = getOracleStoreParameters();

                // diferent column type

                if (attrOrg.getDataType() != attrTrg.getDataType()) {

                        strb = new StringBuilder();

                        strb.append("MODIFY (");

                        strb.append(helper.escapeFieldName(attrTrg.getName()));

                        strb.append(" ");

                        strb.append(helper.getSqlColumnTypeDescription(attrTrg));

                        strb.append(")");

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

                                additionalStatement.add(getSqlGeometryFieldDrop(attrOrg));

                        }

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

                                additionalStatement.addAll(((OracleHelper) helper)

                                                .getSqlGeometryFieldAdd(attrTrg, params.getTable(),

                                                                params.getSchema()));

                        }

                        actions.add(strb.toString());

                }

                if (attrOrg.allowNull() != attrTrg.allowNull()) {

                        strb = new StringBuilder();

                        strb.append("MODIFY (");

                        strb.append(helper.escapeFieldName(attrTrg.getName()));

                        strb.append(" ");

                        if (attrTrg.allowNull()) {

                                strb.append("SET ");

                        } else {

                                strb.append("DROP ");

                        }

                        strb.append("NOT NULL)");

                        actions.add(strb.toString());

                }

                if (attrOrg.getDefaultValue() != attrTrg.getDefaultValue()) {

                        if (attrTrg.getDefaultValue() == null) {

                                strb = new StringBuilder();

                                strb.append("MODIFY (");

                                strb.append(helper.escapeFieldName(attrTrg.getName()));

                                strb.append(" DROP DEFAULT)");

                                actions.add(strb.toString());

                        } else if (!attrTrg.getDefaultValue().equals(

                                        attrOrg.getDefaultValue())) {

                                // ALTER [ COLUMN ] column DROP DEFAULT

                                strb = new StringBuilder();

                                strb.append("MODIFY (");

                                strb.append(helper.escapeFieldName(attrTrg.getName()));

                                strb.append(" SET DEFAULT ");

                                strb.append(helper.dalValueToJDBC(attrTrg, attrTrg

                                                .getDefaultValue()));

                                strb.append(")");

                                actions.add(strb.toString());

                        }

                }

                if (attrOrg.getDataType() == attrTrg.getDataType()

                                && attrTrg.getDataType() == DataTypes.GEOMETRY) {

                        // TODO Checks SRS and GeomType/Subtype

                }

                return actions;

        }

        private Object getSqlGeometryFieldDrop(FeatureAttributeDescriptor attr) {

                StringBuilder strb = new StringBuilder();

                OracleStoreParameters params = getOracleStoreParameters();

                // DELETE FROM USER_SDO_GEOM_METADATA WHERE TABLE_NAME like 'XX' And

                // COLUMN_NAME like 'GEOMETRY';

                strb.append("DELETE FROM ");

                strb.append(OracleValues.USER_ORACLE_GEOMETADATA_VIEW);

                strb.append(" WHERE ");

                strb.append(OracleValues.USER_ORACLE_GEOMETADATA_VIEW_TABLE_NAME);

                strb.append(" like '");

                strb.append(params.getTable());

                strb.append("' AND ");

                strb.append(OracleValues.USER_ORACLE_GEOMETADATA_VIEW_COLUMN_NAME);

                strb.append(" like '");

                strb.append(attr.getName());

                strb.append("'");

                return strb.toString();

        }

}