Application: gvSIG desktop

package org.gvsig.fmap.dal.store.jdbc2.spi;

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

import org.gvsig.fmap.dal.store.jdbc2.spi.operations.OperationsFactoryBase;

import java.sql.Connection;

import java.sql.ResultSet;

import org.apache.commons.lang3.StringUtils;

import org.apache.commons.lang3.mutable.MutableBoolean;

import org.gvsig.expressionevaluator.Code;

import org.gvsig.expressionevaluator.ExpressionBuilder.GeometrySupportType;

import static org.gvsig.expressionevaluator.ExpressionBuilder.GeometrySupportType.EWKB;

import static org.gvsig.expressionevaluator.ExpressionBuilder.GeometrySupportType.NATIVE;

import static org.gvsig.expressionevaluator.ExpressionBuilder.GeometrySupportType.WKB;

import static org.gvsig.expressionevaluator.ExpressionBuilder.GeometrySupportType.WKT;

import org.gvsig.expressionevaluator.ExpressionEvaluatorLocator;

import org.gvsig.expressionevaluator.ExpressionEvaluatorManager;

import org.gvsig.expressionevaluator.Function;

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.feature.FeatureAttributeDescriptor;

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

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

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

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

import org.gvsig.fmap.dal.resource.spi.ResourceConsumer;

import org.gvsig.fmap.dal.resource.spi.ResourceProvider;

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

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

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

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

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

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

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

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.jdbc2.JDBCHelper;

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

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

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

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

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

import org.gvsig.fmap.dal.store.jdbc2.ResulSetControler.ResultSetEntry;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

import org.gvsig.tools.dispose.impl.AbstractDisposable;

import org.gvsig.tools.evaluator.Evaluator;

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.exception.NotYetImplemented;

import org.gvsig.tools.visitor.VisitCanceledException;

import org.gvsig.tools.visitor.Visitor;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

@SuppressWarnings("UseSpecificCatch")

public class JDBCHelperBase extends AbstractDisposable implements ResourceConsumer, JDBCHelper {

    private static final boolean ALLOW_AUTOMATIC_VALUES = true;

    private static final String QUOTE_FOR_USE_IN_IDENTIFIERS = "\"";

    private static final String QUOTE_FOR_USE_IN_STRINGS = "'";

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

    private ResulSetControler resulSetControler = null;

    // Quien ha creado este helper.

    // Se le reenviaran las notificaciones del recurso asociado al helper.

    private ResourceConsumer helperClient = null;

    private GeometryManager geometryManager = null;

    private JDBCConnectionParameters connectionParameters;

    private JDBCStoreProvider store;    

    protected OperationsFactory operationsFactory = null;

    protected SRSSolver srssolver;

    public JDBCHelperBase(JDBCConnectionParameters connectionParameters) {

        this.connectionParameters = connectionParameters;

        // If a particular treatment is required to convert SRS to the 

        // BBDD format, overwrite JDBCSRSsBase and use it instead of JDBCSRSsDumb.

        this.srssolver = new SRSSolverDumb(this);

    }

    protected void initialize(

            ResourceConsumer helperClient,

            JDBCConnectionParameters connectionParameters,

            JDBCStoreProvider store

        ) {

        this.store = store;

        this.helperClient = helperClient;

        this.connectionParameters = connectionParameters;

        initializeResource(connectionParameters);        

    }

    protected String getResourceType() {

        return JDBCResource.NAME;

    }

    @Override

    public String getProviderName() {

        return JDBCLibrary.NAME;

    }

    @Override

    public GeometrySupportType getGeometrySupportType() {

        // El proveedor generico de JDBC guadara las geoemtrias como WKT

        return GeometrySupportType.WKT;

    }

    @Override

    public boolean hasSpatialFunctions() {

        // Por defecto el proveedor generico de JDBC asume que la BBDD no 

        // tiene soporte para funciones espaciales.

        return false;

    }

    @Override

    public boolean allowNestedOperations() {

        return false;

    }

    @Override

    public boolean canWriteGeometry(int geometryType, int geometrySubtype) {

        // Como va a guardar las geometrias en WKT, puede escribirlas todas.

        return true;

    }

    @Override

    public JDBCSQLBuilderBase createSQLBuilder() {

        return new JDBCSQLBuilderBase(this);

    }

    @Override

    public String getQuoteForIdentifiers() {

        return QUOTE_FOR_USE_IN_IDENTIFIERS;

    }

    @Override

    public boolean allowAutomaticValues() {

        return ALLOW_AUTOMATIC_VALUES;

    }

    @Override

    public boolean supportOffsetInSelect() {

        // Asumimos que la BBDD soporta OFFSET

        return true;

    }

    @Override

    public String getQuoteForStrings() {

        return QUOTE_FOR_USE_IN_STRINGS;

    }

    @Override

    public boolean supportFilter(Evaluator filter) {

        // No podemos filtrar cuando:

        // - Hay una subquery especificada en los parametros 

        // - Si hay un filtro y el getSQL devuelbe null.

        // - Si se esta usando alguna funcion no-sql en el getSQL

        // - Si se estan usando funciones OGC y no soportamos funciones espaciales

        // 

        // Un proveedor especifico podria sobreescribir el metodo,

        // para hilar mas fino al comprobar si soporta el filtro o no.

        //

        if (this.useSubquery()) {

            // Se esta usando una subquery en los parametros de acceso a la

            // BBDD, asi que no podemos filtrar.

            return false;

        }

        if (filter == null) {

            // No hay que filtrar nada, asi que se p?ede.

            return true;

        }

        String sql = filter.getSQL();

        if (StringUtils.isEmpty(sql)) {

            // Hay un filtro, pero la SQL es null, con lo que no podemos

            // filtrar por el.

            return false;

        }

        // Ahora vamos a comprobar que las funciones que se usan son 

        // compatibles sql, y que no se usan funciones OGC si el 

        // proveedor dice que no soporta funciones espaciales.

        final MutableBoolean isCompatible = new MutableBoolean(true);

        final boolean supportSpatialFunctions = this.hasSpatialFunctions();

        ExpressionEvaluatorManager manager = ExpressionEvaluatorLocator.getManager();

        Code code = manager.compile(sql);

        try {

            code.accept(new Visitor() {

                @Override

                public void visit(Object code_obj) throws VisitCanceledException, BaseException {

                    Code code = (Code) code_obj;

                    if ( code.code()==Code.CALLER ) {

                        Code.Caller caller = (Code.Caller) code;

                        Function function = caller.function();

                        if( function==null ) {

                            isCompatible.setValue(false);

                            throw new VisitCanceledException();

                        }

                        if( !function.isSQLCompatible() ) {

                            isCompatible.setValue(false);

                            throw new VisitCanceledException();

                        }

                        if( !supportSpatialFunctions ) {

                            if( StringUtils.equalsIgnoreCase(function.group(),Function.GROUP_OGC) ) {

                                isCompatible.setValue(false);

                                throw new VisitCanceledException();

                            }

                        }

                    }

                }

            });

        } catch (VisitCanceledException ex) {

            // Do nothing

        } catch (Exception ex) {

            LOGGER.warn("Can't calculate if is SQL compatible.", ex);

        }

        return isCompatible.booleanValue();

    }

    @Override

    public boolean supportOrder(FeatureQueryOrder order) {

        if (this.useSubquery()) {

            return false;

        }

        if (order == null) {

            return true;

        }

        for( FeatureQueryOrder.FeatureQueryOrderMember member : order.members() ) {

            if (member.hasEvaluator()) {

                if( !this.supportFilter(member.getEvaluator()) ) {

                    return false;

                }

            }            

        }

        return true;

    }

    @Override

    public OperationsFactory getOperations() {

        if (this.operationsFactory== null) {

            this.operationsFactory = new OperationsFactoryBase(this);

        }

        return operationsFactory;

    }

    protected void initializeResource(JDBCConnectionParameters params) {

//        Object[] resourceParams = new Object[]{

//            params.getUrl(),

//            params.getHost(),

//            params.getPort(),

//            params.getDBName(),

//            params.getUser(),

//            params.getPassword(),

//            params.getJDBCDriverClassName()

//        };

//

//        try {

//            ResourceManagerProviderServices manager

//                    = (ResourceManagerProviderServices) DALLocator.getResourceManager();

//            JDBCResource resource = (JDBCResource) manager.createAddResource(

//                    this.getResourceType(),

//                    resourceParams

//            );

//            this.resource = resource;

//            this.resource.addConsumer(this);

//        } catch (InitializeException ex) {

//            logger.debug("Can't initialize resource (" + ArrayUtils.toString(resourceParams) + ").", ex);

//            throw new RuntimeException("Can't initialize resource (" + ArrayUtils.toString(resourceParams) + ").", ex);

//        }

    }

    @Override

    public String getSourceId() {

        return this.store.getSourceId();

    }

    @Override

    public JDBCResource getResource() {

        return null;

//        return this.resource;

    }

    @Override

    public Connection getConnection() throws AccessResourceException {

        throw new NotYetImplemented();

    }

    @Override

    public Connection getConnectionWritable() throws AccessResourceException {

        return this.getConnection();

    }

    @Override

    public String getConnectionURL() {

        return null;

    }

    @Override

    public JDBCConnectionParameters getConnectionParameters() {

        return connectionParameters;

    }

    @Override

    public void closeConnection(Connection connection) {

        if( connection != null ) {

            LOGGER.debug("Clossing connection "+connection.hashCode());

            try {

                connection.close();

            } catch(Exception ex) {

                LOGGER.warn("Can't close connection.", ex);

            }

       }

    }

    public void closeConnectionQuietly(Connection connection) {

        if( connection != null ) {

            LOGGER.debug("Clossing connection quietly "+connection.hashCode());

            try {

                connection.close();

            } catch(Exception ex) {

                LOGGER.warn("Can't close connection.", ex);

            }

       }

    }

    @Override

    protected void doDispose() throws BaseException {

        JDBCUtils.closeQuietly(this);

    }

    @Override

    public void close() throws Exception {

//        this.resource.removeConsumer(this);

        JDBCUtils.closeQuietly(this.resulSetControler);

//        this.resource = null;

        this.resulSetControler = null;

    }

    @Override

    public boolean closeResourceRequested(ResourceProvider resource) {

        return this.helperClient.closeResourceRequested(resource);

    }

    @Override

    public void resourceChanged(ResourceProvider resource) {

        this.helperClient.resourceChanged(resource);

    }

    @Override

    public GeometryManager getGeometryManager() {

        if (this.geometryManager == null) {

            this.geometryManager = GeometryLocator.getGeometryManager();

        }

        return this.geometryManager;

    }

    @Override

    public ResulSetControler getResulSetControler() {

        if (this.resulSetControler == null) {

            this.resulSetControler = new ResulSetControlerBase(this);

        }

        return this.resulSetControler;

    }

    @Override

    public void fetchFeature(FeatureProvider feature, ResultSetEntry rs) throws DataException {

        fetchFeature(feature, rs.get(), rs.getColumns());

    }

    @Override

    public void fetchFeature(FeatureProvider feature, ResultSet rs, FeatureAttributeDescriptor[] columns) throws DataException {

        Object value;

        FeatureAttributeDescriptor column;

        try {

            for (int index = 0; index < columns.length; index++) {

                column = columns[index];

                switch (column.getType()) {

                    case DataTypes.GEOMETRY:

                        value = this.getGeometryFromColumn(rs, index + 1);

                        break;

                    default:

                        value = rs.getObject(index + 1);

                }

                feature.set(column.getIndex(), value);

            }

        } catch (Exception ex) {

            throw new JDBCCantFetchValueException(ex);

        }

    }

    @Override

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

        return getGeometryFromColumn(rs.get(), index);

    }

    @Override

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

        try {

            Object value;

            switch (this.getGeometrySupportType()) {

                case NATIVE:

                case WKB:

                    value = rs.getBytes(index);

                    if (value == null) {

                        return null;

                    }

                    return this.getGeometryManager().createFrom((byte[]) value);

                case EWKB:

                    value = rs.getBytes(index);

                    if (value == null) {

                        return null;

                    }

                    return this.getGeometryManager().createFrom((byte[]) value);

                case WKT:

                default:

                    value = rs.getString(index);

                    if (value == null) {

                        return null;

                    }

                    return this.getGeometryManager().createFrom((String) value);

            }

        } catch (Exception ex) {

            throw new JDBCCantFetchValueException(ex);

        }

    }

    @Override

    public FeatureProvider createFeature(FeatureType featureType) throws DataException {

        return this.store.getStoreServices().createDefaultFeatureProvider(featureType);

    }

    @Override

    public boolean useSubquery() {

        if( this.store == null ) {

            return false;

        }

        return !StringUtils.isEmpty(this.store.getParameters().getSQL());

    }  

    @Override

    public SRSSolver getSRSSolver() {

        return this.srssolver;

    }

    @Override

    public JDBCStoreProvider createProvider(

            JDBCStoreParameters parameters, 

            DataStoreProviderServices providerServices

        ) throws InitializeException {

        JDBCStoreProviderBase theStore = new JDBCStoreProviderBase(

                parameters, 

                providerServices, 

                DBHelper.newMetadataContainer(JDBCLibrary.NAME),

                this

        );

        this.initialize(theStore, parameters, theStore);

        return theStore;

    }

    @Override

    public JDBCServerExplorer createServerExplorer(

            JDBCServerExplorerParameters parameters, 

            DataServerExplorerProviderServices providerServices

        ) throws InitializeException {

        JDBCServerExplorer explorer = new JDBCServerExplorerBase(

                parameters, 

                providerServices, 

                this

        );

        this.initialize(explorer, parameters, null);

        return explorer;

    }

    @Override

    public JDBCNewStoreParameters createNewStoreParameters() {

        return new JDBCNewStoreParameters();

    }

    @Override

    public JDBCStoreParameters createOpenStoreParameters() {

        return new JDBCStoreParameters();

    }

    @Override

    public JDBCServerExplorerParameters createServerExplorerParameters() {

        return new JDBCServerExplorerParameters();

    }

    @Override

    public String getSourceId(JDBCStoreParameters parameters) {

        return parameters.getHost() + ":" +

               parameters.getDBName() + ":" + 

               parameters.getSchema()+ ":" + 

               parameters.tableID();

    }

}