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.cresques.cts.IProjection;

import org.gvsig.fmap.crs.CRSFactory;

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.ExpressionBuilder.GeometrySupportType;

import static org.gvsig.fmap.dal.ExpressionBuilder.GeometrySupportType.EWKB;

import static org.gvsig.fmap.dal.ExpressionBuilder.GeometrySupportType.WKB;

import static org.gvsig.fmap.dal.ExpressionBuilder.GeometrySupportType.WKT;

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

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.exception.BaseException;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

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

//    protected JDBCResource resource = null;

    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;

    public JDBCHelperBase(JDBCConnectionParameters connectionParameters) {

        this.connectionParameters = connectionParameters;

    }

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

    }

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

//        return this.resource.getJDBCConnection();

        return null;

    }

    @Override

    public String getConnectionURL() {

        return null;

    }

    public JDBCConnectionParameters getConnectionParameters() {

        return connectionParameters;

    }

    @Override

    public void closeConnection(Connection connection) {

//        this.getResource().closeConnection(connection);

        JDBCUtils.closeQuietly(connection);

       }

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

    }

    @Override

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

        try {

            int index;

            Object value;

            for (FeatureAttributeDescriptor attr : feature.getType()) {

                index = attr.getIndex();

                switch (attr.getType()) {

                    case DataTypes.GEOMETRY:

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

                        break;

                    default:

                        value = rs.getObject(index + 1);

                }

                feature.set(index, 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 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 int getSRSCode(IProjection crs) {

        // Dumb implementation

        String abrev = crs.getAbrev();

        if( StringUtils.isEmpty(abrev) ) {

            return -1;

        }

        String[] ss = abrev.split(":");

        if( ss.length < 2 ) {

            return -1;

        } 

        int id = Integer.parseInt(ss[1]);

        return id;

    }

    @Override

    public IProjection getProjectionFromSRSId(int srsid) {

        // Dumb implementation

        if( srsid < 2000 ) {

            return null;

        }

        IProjection proj = CRSFactory.getCRS("EPSG:"+srsid);

        return proj;

    }

    @Override

    public JDBCStoreProvider createProvider(

            JDBCStoreParameters parameters, 

            DataStoreProviderServices providerServices

        ) throws InitializeException {

        JDBCStoreProviderBase store = new JDBCStoreProviderBase(

                parameters, 

                providerServices, 

                DBHelper.newMetadataContainer(JDBCLibrary.NAME),

                this

        );

        this.initialize(store, parameters, store);

        return store;

    }

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

    }

    public JDBCServerExplorerParameters createServerExplorerParameters() {

        return new JDBCServerExplorerParameters();

    }

    @Override

    public String getSourceId(JDBCStoreParameters parameters) {

        return parameters.getHost() + ":" +

               parameters.getDBName() + ":" + 

               parameters.getSchema()+ ":" + 

               parameters.tableID();

    }

}