gvSIG data provider for Oracle

<?xml version="1.0"?>

<definitions>

  <version>1.0.0</version>

  <classes>

    <class name="Oracle" namespace="Metadata">

      <extends>

      	<class name="JDBC2" namespace="Metadata"/>

      </extends>

      <description>Metadata of a Oracle store</description>

      <fields>

      </fields>

    </class>

  </classes>

</definitions>  

<?xml version="1.0"?>

<definitions>

  <version>1.0.0</version>

  <classes>

    <class name="OracleResourceParameters">

      <extends>

        <class>JDBC2ResourceParameters</class>

      </extends>

      <fields>

        <field name="JDBCDriverClass" type="string" mandatory="true"

          defaultValue="oracle.jdbc.driver.OracleDriver" group="Advanced">

          <description>JDBC Driver class</description>

        </field>

		<field name="port" type="integer" mandatory="false"

          defaultValue="1521" group="Connection">

          <description></description>

        </field>

        <field name="host" type="string" mandatory="false" 

            defaultValue="127.0.0.1" group="Connection">

          <description></description>

        </field>

      </fields>

    </class>

    <class name="OracleStoreParameters">

      <extends>

        <class>JDBC2StoreParameters</class>

        <class>OracleResourceParameters</class>

      </extends>

      <fields/>

    </class>

    <class name="OracleNewStoreParameters">

      <extends>

        <class>JDBC2NewStoreParameters</class>

        <class>OracleResourceParameters</class>

      </extends>

      <fields/>

    </class>

    <class name="OracleServerExplorerParameters">

      <extends>

        <class>OracleResourceParameters</class>

        <class>JDBC2ServerExplorerParameters</class>

      </extends>

      <fields/>

    </class>

  </classes>

</definitions>  

org.gvsig.oracle.dal.OracleLibrary

package org.gvsig.oracle.dal;

import java.nio.ByteBuffer;

import java.nio.ByteOrder;

import java.sql.Connection;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.text.MessageFormat;

import java.util.ArrayList;

import java.util.List;

import org.apache.commons.dbcp.BasicDataSource;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.expressionevaluator.ExpressionBuilder;

import org.gvsig.expressionevaluator.GeometryExpressionBuilderHelper;

import static org.gvsig.fmap.dal.DataManager.FUNCTION_EXISTS;

import org.gvsig.fmap.dal.SQLBuilder;

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

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

import org.gvsig.fmap.dal.resource.exception.AccessResourceException;

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

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

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

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

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

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

import org.gvsig.fmap.dal.store.jdbc2.OperationsFactory;

import org.gvsig.fmap.dal.store.jdbc2.spi.JDBCHelperBase;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.oracle.dal.operations.OracleOperationsFactory;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class OracleHelper extends JDBCHelperBase {

    static final Logger logger = LoggerFactory.getLogger(OracleHelper.class);

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

    public static String getConnectionURL(OracleConnectionParameters params) {

        return getConnectionURL(

            params.getHost(),

            params.getPort(),

            params.getDBName()

        );

    }

    public static String getConnectionURL(String host, Integer port, String db) {

        if( StringUtils.isEmpty(host) ) {

            throw new IllegalArgumentException("Parameter 'host' can't be null.");

        }

        if( port==null ) {

            throw new IllegalArgumentException("Parameter 'port' can't be null.");

        }

        if( StringUtils.isEmpty(db) ) {

            throw new IllegalArgumentException("Parameter 'db' can't be null.");

        }

        //

        // http://docs.oracle.com/cd/E11882_01/appdev.112/e13995/oracle/jdbc/OracleDriver.html

        //

        String connectionURL = MessageFormat.format(

            "jdbc:oracle:thin:@{0}:{1,number,######}:{2}",

            host,

            port,

            db

        );

        logger.debug("connectionURL: {}", connectionURL);

        return connectionURL;

    }

    public static class ConnectionProviderImpl {

        private static boolean needRegisterDriver = true;

        private BasicDataSource dataSource = null;

        private final OracleConnectionParameters connectionParameters;

        public ConnectionProviderImpl(OracleConnectionParameters connectionParameters) {

            this.connectionParameters = connectionParameters;

        }

        public Connection getConnection() throws SQLException {

            if (this.dataSource == null) {

                this.dataSource = this.createDataSource();

                this.dataSource.setAccessToUnderlyingConnectionAllowed(true);

            }

            Connection conn = this.dataSource.getConnection();

            return conn;

        }

        private BasicDataSource createDataSource() throws SQLException {

            if (!this.isRegistered()) {

                this.registerDriver();

            }

            OracleConnectionParameters params = connectionParameters;

            BasicDataSource ds = new BasicDataSource();

            ds.setDriverClassName(params.getJDBCDriverClassName());

            if( !StringUtils.isEmpty(params.getUser()) ) {

                ds.setUsername(params.getUser());

            }

            if( !StringUtils.isEmpty(params.getPassword()) ) {

                ds.setPassword(params.getPassword());

            }

            ds.setUrl(params.getUrl());

            ds.setMaxWait(60L * 1000);

            return ds;

        }

        private boolean isRegistered() {

            return needRegisterDriver;

        }

        public void registerDriver() throws SQLException {

            String className = this.connectionParameters.getJDBCDriverClassName();

            if (className == null) {

                return;

            }

            try {

                Class theClass = Class.forName(className);

                if (theClass == null) {

                    throw new JDBCDriverClassNotFoundException(OracleLibrary.NAME, className);

                }

            } catch (Exception e) {

                throw new SQLException("Can't register JDBC driver '" + className + "'.", e);

            }

            needRegisterDriver = false;

        }

    }

    private ConnectionProviderImpl connectionProvider = null;

    public OracleHelper(JDBCConnectionParameters connectionParameters) {

        super(connectionParameters);

    }

    /**

     * Constructor for use only for testing purposes.

     * @param connectionParameters

     * @param connectionProvider

     */

    public OracleHelper(JDBCConnectionParameters connectionParameters, ConnectionProviderImpl connectionProvider) { 

        super(connectionParameters);

        this.connectionProvider = connectionProvider;

    }

    @Override

    public Connection getConnection() throws AccessResourceException {

        try {

            if (this.connectionProvider == null) {

                this.connectionProvider = new ConnectionProviderImpl(this.getConnectionParameters());

            }

            return this.connectionProvider.getConnection();

        } catch (SQLException ex) {

            throw new AccessResourceException(OracleLibrary.NAME, ex);

        }

    }

    @Override

    public OracleConnectionParameters getConnectionParameters() {

        return (OracleConnectionParameters) super.getConnectionParameters();

    }

    @Override

    public String getConnectionURL() {

        return getConnectionURL(this.getConnectionParameters());

    }

    @Override

    protected String getResourceType() {

        return OracleLibrary.NAME;

    }

    @Override

    public String getProviderName() {

        return OracleLibrary.NAME;

    }

    @Override

    public OracleSQLBuilder createSQLBuilder() {

        return new OracleSQLBuilder(this);

    }

    @Override

    public OperationsFactory getOperations() {

        if (this.operationsFactory == null) {

            this.operationsFactory = new OracleOperationsFactory(this);

        }

        return operationsFactory;

    }

    @Override

    public GeometryExpressionBuilderHelper.GeometrySupportType getGeometrySupportType() {

        return GeometryExpressionBuilderHelper.GeometrySupportType.WKB;

    }

    @Override

    public boolean hasSpatialFunctions() {

        return true;

    }

    @Override

    public boolean canWriteGeometry(int geometryType, int geometrySubtype) {

        return true;

    }

    @Override

    public String getQuoteForIdentifiers() {

        return "\"";

    }

    @Override

    public boolean allowAutomaticValues() {

        return true;

    }

    @Override

    public boolean supportOffsetInSelect() {

        return true;

    }

    @Override

    public String getQuoteForStrings() {

        return "\'";

    }

    @Override

    public String getSourceId(JDBCStoreParameters parameters) {

        return parameters.getDBName() + "." + 

               parameters.getSchema()+ "." + 

               parameters.getTable();

    }

    @Override

    public JDBCNewStoreParameters createNewStoreParameters() {

        return new OracleNewStoreParameters();

    }

    @Override

    public JDBCStoreParameters createOpenStoreParameters() {

        return new OracleStoreParameters();

    }

    @Override

    public JDBCServerExplorerParameters createServerExplorerParameters() {

        return new OracleExplorerParameters();

    }

    @Override

    public Geometry getGeometryFromColumn(ResultSet rs, int index) throws DataException {

        try {

	        // Oracle uses non-standard WKB encoding for rectangles (used in bounding boxes)

	        // Correct it when needed

	        byte[] wkb = (byte[]) rs.getBytes(index);

                if(wkb!=null){

                    ByteBuffer data = ByteBuffer.wrap(wkb);

                    byte endian = data.get();

                    if (endian == 1) {

                        data.order(ByteOrder.LITTLE_ENDIAN);

                    }

                    int typeword = data.getInt();

                    int realtype = typeword & 0x1FFFFFFF; // cut off high flag bits

                    if (realtype==3) { // polygon

                            int rings = data.getInt();

                            if (rings==1) {

                                    int count = data.getInt();

                                    if (count==2) { // Declares 2 points but it has in fact 5

                                            data.putInt(9, 5);

                                    }

                            }

                    }

                    return this.getGeometryManager().createFrom(wkb);

                }

        } catch (Exception ex) {

            throw new JDBCCantFetchValueException(ex);

        }

        return null;

    }

    @Override

    public void processSpecialFunctions(

            SQLBuilder sqlbuilder,

            FeatureType type,

            List<String> extra_column_names) {

        replaceForeingValueFunction(sqlbuilder, type, extra_column_names);

        replaceExistsFunction(sqlbuilder, type, extra_column_names);

    }

    private void replaceExistsFunction(

            SQLBuilder sqlbuilder,

            FeatureType type,

            final List<String> extra_column_names) {

        //  Si lse encuentra una construccion del tipo:

        //    SELECT ... FROM ... WHERE ... EXISTS(list, 'EXISTS_ID') ...

        //  se traslada a:

        //    SELECT ... EXISTS(list) AS EXISTS_ID FROM ... WHERE ... EXISTS(list) ...

        //  Y se a?ade el valor ESISTS_ID a las columnas extra a recuperar de la consulta.

        //          

        final SQLBuilder.SelectBuilder select = sqlbuilder.select();

        final ExpressionBuilder where = select.where();

        if (where == null || where.isEmpty() || select.has_group_by()) {

            return;

        }

        final List<ExpressionBuilder.Value[]> value_replacements = new ArrayList<>();

        where.accept(new ExpressionBuilder.Visitor() {

            @Override

            public void visit(ExpressionBuilder.Visitable value) {

                if (!(value instanceof ExpressionBuilder.Function)) {

                    return;

                }

                ExpressionBuilder.Function function = (ExpressionBuilder.Function) value;

                if (!StringUtils.equalsIgnoreCase(function.name(), FUNCTION_EXISTS)) {

                    return;

                }

                if (function.parameters().size() != 2) {

                    return;

                }

                ExpressionBuilder.Value arg0 = function.parameters().get(0);

                ExpressionBuilder.Value arg1 = function.parameters().get(1);

                if (arg1 == null) {

                    return;

                }

                String columnName = (String) ((ExpressionBuilder.Constant) arg1).value();

                SQLBuilder.SelectColumnBuilder column = select.column();

//               Instead of add column with "EXISTS" function, 

//               we add a column with "CASE" function 

//               for convert result of "EXISTS" to integer.

//               "CASE WHEN {FUNCTION_EXISTS} THEN 1 ELSE 0 END", 

                column.value(

                    sqlbuilder.expression().function(

                            "CASE",

                            sqlbuilder.expression().function(FUNCTION_EXISTS, arg0),

                            sqlbuilder.expression().constant(1),

                            sqlbuilder.expression().constant(0)

                    )

                );

                column.as(columnName);

                if (extra_column_names != null) {

                    extra_column_names.add(columnName);

                }

            }

        }, null);

        if (value_replacements.isEmpty()) {

            return;

        }

        // Realizamos los reemplazos calculados previamente (value_replacements).

        for (ExpressionBuilder.Value[] replaceValue : value_replacements) {

            ExpressionBuilder.Value target = replaceValue[0];

            ExpressionBuilder.Value replacement = replaceValue[1];

            sqlbuilder.select().replace(target, replacement);

        }

    }

}

package org.gvsig.oracle.dal;

import org.gvsig.fmap.dal.DataParameters;

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

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

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

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

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

import org.gvsig.fmap.dal.store.jdbc2.JDBCStoreProvider;

import org.gvsig.fmap.dal.store.jdbc2.impl.JDBCStoreProviderFactory;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class OracleStoreProviderFactory extends JDBCStoreProviderFactory {

    private static final Logger LOGGER = LoggerFactory.getLogger(OracleStoreProviderFactory.class);

    public OracleStoreProviderFactory() {

        super(

                OracleLibrary.NAME, 

                OracleLibrary.NAME + " store"

        );

    }

    @Override

    public JDBCStoreProvider createProvider(

            DataParameters parameters,

            DataStoreProviderServices providerServices

    ) throws InitializeException {

        JDBCHelper helper = new OracleHelper((JDBCConnectionParameters) parameters);

        JDBCStoreProvider provider = null;

        try {

	        provider = helper.createProvider(

	                (JDBCStoreParameters) parameters, 

	                providerServices

	        );

        }

        catch (Exception exc) {

            LOGGER.error("Can't create Oracle provider", exc);

        }

        return provider;

    }

    @Override

    public JDBCStoreParameters createParameters() {

        JDBCStoreParameters params = new OracleStoreParameters();

        return params;

    }

    public boolean preferNotToUseNonNullRestrictions() {

    	return true;

    }

}

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

*

 */

package org.gvsig.oracle.dal;

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

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

public class OracleStoreParameters extends JDBCStoreParameters implements OracleConnectionParameters {

    private final OracleConnectionParametersHelper helper;

    public OracleStoreParameters() {

        super(

                OracleLibrary.NAME + "StoreParameters",

                OracleLibrary.NAME

        );

        this.helper = new OracleConnectionParametersHelper(this);

    }

    @Override

    public String getUrl() {

        return this.helper.getUrl();

    }

    @Override

    public void validate() throws ValidateDataParametersException {

        this.helper.validate();

        super.validate();

    }

    @Override

    public void setDynValue(String name, Object value) {

    	if (!URL_PARAMTER_NAME.equals(name)) {

    		// reset URL each time a parameter changes

    		super.setDynValue(URL_PARAMTER_NAME, null);

    	}

    	super.setDynValue(name, value);

    }

}

/*

 * To change this license header, choose License Headers in Project Properties.

 * To change this template file, choose Tools | Templates

 * and open the template in the editor.

 */

package org.gvsig.oracle.dal;

import java.sql.Connection;

import java.sql.PreparedStatement;

import java.sql.ResultSet;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.fmap.dal.store.jdbc2.JDBCUtils;

import org.gvsig.oracle.dal.operations.OracleUpdateSpatialIndexAndMetadata;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 *

 * @author fdiaz

 */

public class SpatialIndexUtils {

        private static final Logger LOGGER = LoggerFactory.getLogger(OracleUpdateSpatialIndexAndMetadata.class);

        public static String getSpatialIndexName(String table, String geomColumn) {

            return ("SDX_" + table + "_" + geomColumn).toUpperCase();

        }

        public static String getSpatialIndex(Connection connection, String schema, String table, String geomColumnName) {

        ResultSet rs = null;

        PreparedStatement st = null;

        try {

            String sql = "SELECT SDO_INDEX_NAME "

                    + "FROM ALL_SDO_INDEX_METADATA tmd, ALL_SDO_INDEX_INFO tinfo "

                    + "WHERE tmd.SDO_INDEX_OWNER = tinfo.SDO_INDEX_OWNER "

                    + "AND tmd.SDO_INDEX_NAME = tinfo.INDEX_NAME "

                    + "AND TABLE_OWNER = ? AND TABLE_NAME = ? AND COLUMN_NAME = ?";

            st = connection.prepareStatement(sql);

            st.setString(1, schema);

            st.setString(2, table);

            st.setString(3, geomColumnName);

            rs = JDBCUtils.executeQuery(st, sql);

            String indexName;

            if (rs.next()) {

                indexName = rs.getString(1);

                return indexName;

            }

        } catch (Exception ex) {

            LOGGER.debug("Can't get geometry type from column '" + geomColumnName + "'.", ex);

        } finally {

            JDBCUtils.closeQuietly(rs);

            JDBCUtils.closeQuietly(st);

        }

        return null;

    }

    public static boolean isValidSpatialIndex(Connection connection, String table) {

        ResultSet rs = null;

        PreparedStatement st = null;

        try {

            String sql = "SELECT DOMIDX_status, domidx_opstatus "

                    + "FROM all_indexes "

                    + "WHERE TABLE_NAME = ?"

                    + " and INDEX_TYPE = 'DOMAIN'";

            st = connection.prepareStatement(sql);

            st.setString(1, table);

            rs = JDBCUtils.executeQuery(st, sql);

            String status;

            String opstatus;

            if (rs.next()) {

                status = rs.getString(1);

                opstatus = rs.getString(2);

                return StringUtils.equalsIgnoreCase(status, "VALID") && StringUtils.equalsIgnoreCase(opstatus, "VALID");

            }

        } catch (Exception ex) {

            LOGGER.debug("Can't get status from index.", ex);

        } finally {

            JDBCUtils.closeQuietly(rs);

            JDBCUtils.closeQuietly(st);

        }

        return false;

    }

}

package org.gvsig.oracle.dal;

import org.gvsig.fmap.dal.resource.db.DBParameters;

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

public interface OracleConnectionParameters extends JDBCConnectionParameters, DBParameters {

}

package org.gvsig.oracle.dal;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.fmap.dal.DataParameters;

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

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

public class OracleConnectionParametersHelper {

    private final JDBCConnectionParameters parameters;

    public OracleConnectionParametersHelper(JDBCConnectionParameters parameters) {

        this.parameters = parameters;

    }

    public String getUrl() {

        String url = (String) this.getDynValue(JDBCConnectionParameters.URL_PARAMTER_NAME);

        if( StringUtils.isEmpty(url) ) {

            url = OracleHelper.getConnectionURL((OracleConnectionParameters) this.parameters);

            this.setDynValue(JDBCConnectionParameters.URL_PARAMTER_NAME,url);

        }

        return url;

    }

    public void validate() throws ValidateDataParametersException {

        if (this.getDynValue(JDBCConnectionParameters.JDBC_DRIVER_CLASS_PARAMTER_NAME) == null) {

            this.setDynValue(

                JDBCConnectionParameters.JDBC_DRIVER_CLASS_PARAMTER_NAME,

                OracleHelper.ORACLE_JDBC_DRIVER

            );

        }

        if( this.getDynValue(JDBCConnectionParameters.PORT_PARAMTER_NAME)==null ) {

            this.setDynValue(JDBCConnectionParameters.PORT_PARAMTER_NAME, 1521);

        }

		if ( StringUtils.isEmpty((CharSequence) this.getDynValue(JDBCConnectionParameters.URL_PARAMTER_NAME))) {

            String url = OracleHelper.getConnectionURL(

                parameters.getHost(),

                parameters.getPort(),

                parameters.getDBName()

            );

            this.setDynValue(JDBCConnectionParameters.URL_PARAMTER_NAME, url);

		}

    }

    private Object getDynValue(String name) {

        return ((DataParameters)this.parameters).getDynValue(name);

    }

    private void setDynValue(String name, Object value) {

        ((DataParameters)this.parameters).setDynValue(name,value);

    }

}

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

*

 */

/**

 *

 */

package org.gvsig.oracle.dal;

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

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

public class OracleExplorerParameters extends

        JDBCServerExplorerParameters 

    implements

        OracleConnectionParameters

    {

    private final OracleConnectionParametersHelper helper;

    public OracleExplorerParameters() {

        super(

                OracleLibrary.NAME + "ServerExplorerParameters",

                OracleLibrary.NAME

        );

        this.helper = new OracleConnectionParametersHelper(this);

    }

    @Override

    public String getUrl() {

        return this.helper.getUrl();

    }

    @Override

    public void validate() throws ValidateDataParametersException {

        this.helper.validate();

        super.validate();

    }

    @Override

    public void setDynValue(String name, Object value) {

    	if (!URL_PARAMTER_NAME.equals(name)) {

    		// reset URL each time a parameter changes

    		super.setDynValue(URL_PARAMTER_NAME, null);

    	}

    	super.setDynValue(name, value);

    }

}

package org.gvsig.oracle.dal;

import org.gvsig.fmap.dal.DALLibrary;

import org.gvsig.fmap.dal.DALLocator;

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

import org.gvsig.fmap.dal.store.db.DBHelper;

import org.gvsig.fmap.dal.store.jdbc2.JDBCLibrary;

import org.gvsig.fmap.dal.store.jdbc2.spi.JDBCStoreProviderBase;

import org.gvsig.metadata.exceptions.MetadataException;

import org.gvsig.tools.library.AbstractLibrary;

import org.gvsig.tools.library.LibraryException;

public class OracleLibrary extends AbstractLibrary {

    public static final String NAME = "Oracle";

    @Override

    public void doRegistration() {

        registerAsServiceOf(DALLibrary.class);

        require(JDBCLibrary.class);

    }

    @Override

    protected void doInitialize() throws LibraryException {

    }

    @Override

    protected void doPostInitialize() throws LibraryException {

        LibraryException ex = null;

        DataManagerProviderServices dataman = 

                (DataManagerProviderServices) DALLocator.getDataManager();

        try {

            Class.forName(OracleHelper.ORACLE_JDBC_DRIVER);

        } catch(Throwable th) {

            OracleHelper.logger.warn("Can't load Oracle JDBC Driver.",th);

        }

        DBHelper.registerParametersDefinition(

                NAME + "StoreParameters",

                OracleStoreParameters.class,

                dataman.getResourceAsStream(this, NAME + "Parameters.xml")

        );

        DBHelper.registerParametersDefinition(

                NAME + "NewStoreParameters",

                OracleNewStoreParameters.class,

                dataman.getResourceAsStream(this, NAME + "Parameters.xml")

        );

        DBHelper.registerParametersDefinition(

                NAME + "ServerExplorerParameters",

                OracleExplorerParameters.class,

                dataman.getResourceAsStream(this, NAME + "Parameters.xml")

        );

        try {

            DBHelper.registerMetadataDefinition(

                NAME,

                JDBCStoreProviderBase.class,

                dataman.getResourceAsStream(this, NAME + "Metadata.xml")

            );

        } catch (MetadataException e) {

            ex = new LibraryException(this.getClass(), e);

        }

        if (!dataman.getStoreProviderRegister().exits(NAME)) {

            dataman.registerStoreProviderFactory(new OracleStoreProviderFactory());

        }

        if (!dataman.getServerExplorerRegister().exits(NAME)) {

            dataman.registerServerExplorerFactory(new OracleExplorerFactory());

        }

        if (ex != null) {

            throw ex;

        }

    }

}

package org.gvsig.oracle.dal.expressionbuilderformatter;

import java.text.MessageFormat;

import java.util.List;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.expressionevaluator.ExpressionBuilder;

import org.gvsig.expressionevaluator.ExpressionBuilder.BinaryOperator;

import org.gvsig.expressionevaluator.ExpressionBuilder.Function;

import org.gvsig.expressionevaluator.ExpressionBuilder.Value;

import org.gvsig.expressionevaluator.Formatter;

import org.gvsig.fmap.dal.SQLBuilder;

import org.gvsig.oracle.dal.OracleSQLBuilder;

/**

 *

 * @author jjdelcerro

 */

class Concat implements Formatter<Value> {

    private final Formatter<Value> formatter;

    private final SQLBuilder builder;

    public Concat(SQLBuilder builder, Formatter<Value> formatter) {

        this.builder = builder;

        this.formatter = formatter;

    }

    @Override

    public boolean canApply(Value value) {

        if (value instanceof BinaryOperator) {

            return StringUtils.equalsIgnoreCase(ExpressionBuilder.OPERATOR_CONCAT, ((BinaryOperator) value).name());

        }

        return false;

    }

    @Override

    public String format(Value function) {

        List<Value> parameters = ((Function) function).parameters();

        String p1 = parameters.get(0).toString(formatter);

        String p2 = parameters.get(1).toString(formatter);

        String r = MessageFormat.format(OracleSQLBuilder.FORMAT_OPERATOR_CONCAT, p1, p2);

        return r;

    }

}

package org.gvsig.oracle.dal.expressionbuilderformatter;

import java.text.MessageFormat;

import java.util.List;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.expressionevaluator.ExpressionBuilder.Function;

import org.gvsig.expressionevaluator.ExpressionBuilder.Value;

import org.gvsig.expressionevaluator.Formatter;

import org.gvsig.expressionevaluator.GeometryExpressionBuilder;

import org.gvsig.fmap.dal.SQLBuilder;

/**

 *

 * @author jjdelcerro

 */

class ST_SRID implements Formatter<Value> {

    private final Formatter<Value> formatter;

    private final SQLBuilder builder;

    public ST_SRID(SQLBuilder builder, Formatter<Value> formatter) {

        this.builder = builder;

        this.formatter = formatter;

    }

    @Override

    public boolean canApply(Value value) {

        if (value instanceof Function) {

            return StringUtils.equalsIgnoreCase(GeometryExpressionBuilder.FUNCTION_ST_SRID, ((Function) value).name());

        }

        return false;

    }

    @Override

    public String format(Value function) {

        List<Value> parameters = ((Function) function).parameters();

        String p1 = parameters.get(0).toString(formatter);

        String r = MessageFormat.format("(({0}).SDO_SRID)", p1);

        return r;

    }

}

package org.gvsig.oracle.dal.expressionbuilderformatter;

import org.apache.commons.lang3.StringUtils;

import static org.gvsig.expressionevaluator.ExpressionBuilder.FUNCTION_GETATTR;

import org.gvsig.expressionevaluator.ExpressionBuilder.Function;

import org.gvsig.expressionevaluator.ExpressionBuilder.Value;

import org.gvsig.expressionevaluator.ExpressionBuilder.Variable;

import org.gvsig.expressionevaluator.ExpressionBuilder.Constant;

import org.gvsig.expressionevaluator.Formatter;

import org.gvsig.fmap.dal.SQLBuilder;

/**

 *

 * @author jjdelcerro

 */

public class Getattr implements Formatter<Value> {

    private final SQLBuilder sqlbuilder;

    private final Formatter<Value> formatter;

    public Getattr(SQLBuilder sqlbuilder, Formatter<Value> formatter) {

        this.sqlbuilder = sqlbuilder;

        this.formatter = formatter;

    }

    @Override

    public boolean canApply(Value value) {

        if (value instanceof Function) {

            if( StringUtils.equalsIgnoreCase(FUNCTION_GETATTR, ((Function) value).name()) ) {

              Value obj = ((Function) value).parameters().get(0);

              Value attrname = ((Function) value).parameters().get(1);

              return obj instanceof Variable && attrname instanceof Constant;

            }

        }

        return false;

    }

    @Override

    public String format(Value function0) {

        Function function = (Function) function0;

        Variable obj = (Variable) function.parameters().get(0);

        Constant attrname = (Constant) function.parameters().get(1);

        return this.sqlbuilder.as_identifier(obj.name())+"."+this.sqlbuilder.as_identifier((String) attrname.value());

    }

}

package org.gvsig.oracle.dal.expressionbuilderformatter;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.expressionevaluator.ExpressionBuilder;

import static org.gvsig.expressionevaluator.ExpressionBuilder.FUNCTION_TUPLE;

import org.gvsig.expressionevaluator.ExpressionBuilder.Function;

import org.gvsig.expressionevaluator.ExpressionBuilder.Value;

import org.gvsig.expressionevaluator.Formatter;

import static org.gvsig.fmap.dal.DataManager.FUNCTION_SELECT;

import org.gvsig.fmap.dal.SQLBuilder;

/**

 *

 * @author jjdelcerro

 */

@SuppressWarnings("UseSpecificCatch")

public class Select implements Formatter<Value> {

    private final Formatter<Value> formatter;

    private final SQLBuilder builder;

    public Select(SQLBuilder builder, Formatter<Value> formatter) {

        this.builder = builder;

        this.formatter = formatter;

    }

    @Override

    public boolean canApply(ExpressionBuilder.Value value) {

        if (value instanceof ExpressionBuilder.Function) {

            return StringUtils.equalsIgnoreCase(FUNCTION_SELECT, ((Function) value).name());

        }

        return false;

    }

    private static final int COLUMNS = 0;

    private static final int TABLE = 1;

    private static final int WHERE = 2;

    private static final int ORDER = 3;

    private static final int ORDER_MODE = 4;

    private static final int LIMIT = 5;

    private StringBuilder appendMainClause(

            StringBuilder builder, 

            Function function) {

        String tableName = (String) function.parameters().get(TABLE).toString(formatter);

        Value where = function.parameters().get(WHERE);

//        Value order = function.parameters().get(ORDER);

//        Value limit = function.parameters().get(LIMIT);

//        Value order_mode = function.parameters().get(ORDER_MODE);

        builder.append("SELECT ");

        try {

            Function columns = (Function) function.parameters().get(COLUMNS);

            if (!StringUtils.equalsIgnoreCase(((ExpressionBuilder.Function) columns).name(), FUNCTION_TUPLE)) {

                throw new IllegalArgumentException();

            }

            if (columns.parameters().isEmpty()) {

                builder.append("* ");

            } else {

                boolean needcomma = false;

                for (Value parameter : columns.parameters()) {

                    if (needcomma) {

                        builder.append(", ");

                    } else {

                        needcomma = true;

                    }

                    builder.append(parameter.toString(formatter));

                }

            }

        } catch (Exception ex) {

            throw new IllegalArgumentException("Invalid columns, need a tuple function as columns.");

        }

        builder.append(" FROM ");

        builder.append(tableName);

        if (where != null) {

            builder.append(" WHERE ");

            builder.append(where.toString(formatter));

        }

        return builder;

    }

    @Override

    public String format(Value function0) {

        Function function = (Function) function0;

        String tableName = (String) function.parameters().get(TABLE).toString(formatter);

//        Value where = function.parameters().get(WHERE);

//        Value order = function.parameters().get(ORDER);

        Value limit = function.parameters().get(LIMIT);

//        Value order_mode = function.parameters().get(ORDER_MODE);

        StringBuilder strBuilder = new StringBuilder();

        strBuilder.append("(");

            if (limit != null) {

                /**

                 * Using ROWNUM for limit & offset, compatible with any Oracle

                 * version This requires wrapping the original query as shown in

                 * the example: select * from ( select a.*, ROWNUM rnum from (

                 * <select statement with order by clause>

                 * ) a where ROWNUM <= MAX_ROW

                 *     ) where rnum >= MIN_ROW because ROWNUM is considered before

                 * applying order by and group by

                 */

                strBuilder.append("SELECT * FROM ( ");

                this.appendMainClause(

                        strBuilder,

                        function);

                strBuilder.append(") a");

                strBuilder.append(" WHERE ROWNUM <= ");

                strBuilder.append(limit);

            } else {

                this.appendMainClause(

                        strBuilder,

                        function);

            }

        strBuilder.append(")");

//        builder.append("(SELECT ");

//

//        try {

//            Function columns = (Function) function.parameters().get(COLUMNS);

//            if (!StringUtils.equalsIgnoreCase(((ExpressionBuilder.Function) columns).name(), FUNCTION_TUPLE)) {

//                throw new IllegalArgumentException();

//            }

//            if (columns.parameters().isEmpty()) {

//                builder.append("* ");

//            } else {

//                boolean needcomma = false;

//                for (Value parameter : columns.parameters()) {

//                    if (needcomma) {

//                        builder.append(", ");

//                    } else {

//                        needcomma = true;

//                    }

//                    builder.append(parameter.toString(formatter));

//                }

//            }

//        } catch (Exception ex) {

//            throw new IllegalArgumentException("Invalid columns, need a tuple function as columns.");

//        }

//

//        builder.append(" FROM ");

//        builder.append(tableName);

//        if (where != null) {

//            builder.append(" WHERE ");

//            builder.append(where.toString(formatter));

//        }

//        if (limit != null) {

//            builder.append(" LIMIT ");

//            builder.append(limit.toString(formatter));

//        }

//        builder.append(")");

        return strBuilder.toString();

    }

}

/*

 * To change this license header, choose License Headers in Project Properties.

 * To change this template file, choose Tools | Templates

 * and open the template in the editor.

 */

package org.gvsig.oracle.dal.expressionbuilderformatter;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.expressionevaluator.ExpressionBuilder;

import org.gvsig.expressionevaluator.Formatter;

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

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

import org.gvsig.fmap.dal.store.jdbc2.OperationsFactory;

import static org.gvsig.fmap.dal.store.jdbc2.spi.JDBCSQLBuilderBase.PROP_FEATURE_TYPE;

import static org.gvsig.fmap.dal.store.jdbc2.spi.JDBCSQLBuilderBase.PROP_TABLE;

import org.gvsig.tools.dataTypes.DataTypes;

/**

 *

 * @author fdiaz

 */

public abstract class AbstractClobOperator implements Formatter<ExpressionBuilder.Value> {

    protected boolean useLob(ExpressionBuilder.Value value) {

        FeatureType featureType = (FeatureType) value.getProperty(PROP_FEATURE_TYPE);

        if(featureType == null){

            return false;

        }

        if (value instanceof ExpressionBuilder.Variable) {

            FeatureAttributeDescriptor descriptor = featureType.getAttributeDescriptor(((ExpressionBuilder.Variable) value).name());

            if (descriptor != null) {

                if (descriptor.getType() == DataTypes.STRING

                        && (descriptor.getSize() < 0 || descriptor.getSize() >= 4096)) {

                    return true;

                }

            }

            return false;

        }

        OperationsFactory.TableReference tableReference = (OperationsFactory.TableReference) value.getProperty(PROP_TABLE);

        if(tableReference == null){

            return false;

        }

        if(value instanceof ExpressionBuilder.Function){

            ExpressionBuilder.Function fn = (ExpressionBuilder.Function)value;

            if(StringUtils.equalsIgnoreCase(ExpressionBuilder.FUNCTION_GETATTR, fn.name())){

                ExpressionBuilder.Value table = fn.parameters().get(0);

                if(table instanceof ExpressionBuilder.Variable){

                    if(((ExpressionBuilder.Variable)table).name() instanceof String && 

                            StringUtils.equals( tableReference.getTable(), (String)((ExpressionBuilder.Variable)table).name())) {

                        if(useLobSimple(featureType, fn.parameters().get(1))){

                            return true;

                        }

                    }

                }

                if(table instanceof ExpressionBuilder.Constant){

                    if(((ExpressionBuilder.Constant)table).value() instanceof String && 

                            StringUtils.equals( tableReference.getTable(), (String)((ExpressionBuilder.Constant)table).value())) {

                        if(useLobSimple(featureType, fn.parameters().get(1))){

                            return true;

                        }

                    }

                }

            }

        }

        return false;

    }

    private boolean useLobSimple(FeatureType featureType, ExpressionBuilder.Value value){

        if (value instanceof ExpressionBuilder.Constant) {

            FeatureAttributeDescriptor descriptor = featureType.getAttributeDescriptor((String)((ExpressionBuilder.Constant) value).value());

            if (descriptor != null) {

                if (descriptor.getType() == DataTypes.STRING

                        && (descriptor.getSize() < 0 || descriptor.getSize() >= 4096)) {

                    return true;

                }

            }

        }

        return false;

    }

}

package org.gvsig.oracle.dal.expressionbuilderformatter;

import java.text.MessageFormat;

import java.util.List;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.expressionevaluator.ExpressionBuilder.Function;

import org.gvsig.expressionevaluator.ExpressionBuilder.Value;

import org.gvsig.expressionevaluator.Formatter;

import org.gvsig.expressionevaluator.GeometryExpressionBuilder;

import org.gvsig.fmap.dal.SQLBuilder;

/**

 *

 * @author jjdelcerro

 */

class ST_Touches implements Formatter<Value> {

    private final Formatter<Value> formatter;

    private final SQLBuilder builder;

    public ST_Touches(SQLBuilder builder, Formatter<Value> formatter) {

        this.builder = builder;

        this.formatter = formatter;

    }

    @Override

    public boolean canApply(Value value) {

        if (value instanceof Function) {

            return StringUtils.equalsIgnoreCase(GeometryExpressionBuilder.FUNCTION_ST_TOUCHES, ((Function) value).name());

        }

        return false;

    }

    @Override

    public String format(Value function) {

        List<Value> parameters = ((Function) function).parameters();

        String p1 = parameters.get(0).toString(formatter);

        // Le falta un par?metro ?no?

//        String r = MessageFormat.format("(SDO_RELATE(({0}) = ''mask=TOUCH'') = ''TRUE'')", p1);

        String p2 = parameters.get(1).toString(formatter);

        String r = MessageFormat.format("(SDO_RELATE({0}, {1}, ''mask=TOUCH'') = ''TRUE'')", p1, p2);

        return r;

    }

}

/*

 * To change this license header, choose License Headers in Project Properties.

 * To change this template file, choose Tools | Templates

 * and open the template in the editor.

 */

package org.gvsig.oracle.dal.expressionbuilderformatter;

import java.text.MessageFormat;

import org.cresques.cts.IProjection;

import org.gvsig.expressionevaluator.ExpressionBuilder;

import static org.gvsig.expressionevaluator.ExpressionBuilder.PARAMETER_TYPE_CONSTANT;

import static org.gvsig.expressionevaluator.ExpressionBuilder.PARAMETER_TYPE_VARIABLE;

import org.gvsig.expressionevaluator.Formatter;

import org.gvsig.expressionevaluator.GeometryExpressionBuilder;

import static org.gvsig.expressionevaluator.GeometryExpressionBuilderHelper.PARAMETER_TYPE_GEOMETRY;

import org.gvsig.fmap.dal.SQLBuilder;

import org.gvsig.oracle.dal.OracleSQLBuilder;

/**

 *

 * @author osc

 */

public class OracleGeometryParameter implements Formatter<ExpressionBuilder.Value> {

    private final Formatter<ExpressionBuilder.Value> formatter;

    private final OracleSQLBuilder builder;

    private final GeometryExpressionBuilder expbuilder;

    public static final String ORACLE_GEOMETRY_PARAMETER = "oracleGeometryParameter";

    public OracleGeometryParameter(SQLBuilder builder, Formatter<ExpressionBuilder.Value> formatter) {

        this.builder = (OracleSQLBuilder) builder;

        this.formatter = formatter;

        this.expbuilder = builder.expression();

    }

    @Override

    public boolean canApply(ExpressionBuilder.Value value) {

        return value instanceof GeometryExpressionBuilder.GeometryParameter;

    }

    @Override

    public String format(ExpressionBuilder.Value param0) {

        GeometryExpressionBuilder.GeometryParameter param = (GeometryExpressionBuilder.GeometryParameter) param0;

        switch (param.type()) {

            case PARAMETER_TYPE_CONSTANT:

            case PARAMETER_TYPE_GEOMETRY:

                if (!(param.value() instanceof Number)) {

                    param.setProperty(ORACLE_GEOMETRY_PARAMETER, true);

                    return MessageFormat.format(

                            "NVL2(({0}),SDO_GEOMETRY(({0}), ({1})),NULL)",

                            "?",

                            getSRS(param)

                    );

                }

            case PARAMETER_TYPE_VARIABLE:

            default:

                return "?";

        }

    }

    private String getSRS(GeometryExpressionBuilder.GeometryParameter param) {

        if( param.srs()!=null ) {

            return param.srs().toString(formatter);

        }

        IProjection proj = param.geometry().getProjection();

        Object s = this.builder.srs_id(proj);

        if( s == null ) {

            throw new IllegalArgumentException("A parameter of type Geometry with an invalid SRS.");

        }

        return s.toString();

    }

}

package org.gvsig.oracle.dal.expressionbuilderformatter;

import java.util.List;

import java.util.Objects;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.expressionevaluator.ExpressionBuilder;

import static org.gvsig.expressionevaluator.ExpressionBuilder.FUNCTION_DECODE;

import org.gvsig.expressionevaluator.ExpressionBuilder.Function;

import org.gvsig.expressionevaluator.ExpressionBuilder.Value;

import org.gvsig.expressionevaluator.Formatter;

import org.gvsig.fmap.dal.SQLBuilder;

/**

 *

 * @author jjdelcerro

 */

public class Decode implements Formatter<Value> {

    private final SQLBuilder sqlbuilder;

    private final Formatter<Value> formatter;

    public Decode(SQLBuilder sqlbuilder, Formatter<Value> formatter) {

        this.sqlbuilder = sqlbuilder;

        this.formatter = formatter;

    }

    @Override

    public boolean canApply(ExpressionBuilder.Value value) {

        if (value instanceof ExpressionBuilder.Function) {

            if( StringUtils.equalsIgnoreCase(FUNCTION_DECODE, ((Function) value).name()) ) {

                List<Value> parameters = ((Function) value).parameters();

                if( parameters.size()==2) {

                    Value p1 = parameters.get(0);

                    Value p2 = parameters.get(1);

                    if( p1 instanceof ExpressionBuilder.Constant && 

                        p2 instanceof ExpressionBuilder.Constant &&

                        ((ExpressionBuilder.Constant)p1).value() instanceof String &&

                        ((ExpressionBuilder.Constant)p2).value() instanceof String 

                        ) {

                        String p2value = ((ExpressionBuilder.Constant)p2).value().toString();

                        if( StringUtils.equalsIgnoreCase(p2value, "hex") ) {

                            return true;

                        }

                    }

                }

            }

        }

        return false;