Application: gvSIG desktop

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

import java.text.MessageFormat;

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

import java.util.Arrays;

import java.util.Collections;

import java.util.Iterator;

import java.util.List;

import org.apache.commons.lang3.BooleanUtils;

import org.apache.commons.lang3.StringUtils;

import org.cresques.cts.IProjection;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataServerExplorer;

import org.gvsig.fmap.dal.DataStore;

import org.gvsig.fmap.dal.DataStoreNotification;

import org.gvsig.fmap.dal.DataTypes;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

import org.gvsig.fmap.dal.resource.ResourceParameters;

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

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

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

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

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

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

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

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

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

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.impl.JDBCSetProvider;

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

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

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

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

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

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

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

import org.gvsig.fmap.geom.Geometry;

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

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.dynobject.exception.DynFieldNotFoundException;

import org.gvsig.tools.exception.BaseException;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

@SuppressWarnings("UseSpecificCatch")

public class JDBCStoreProviderBase

        extends AbstractFeatureStoreProvider

        implements ResourceConsumer, JDBCStoreProvider {

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

    public class CountValue implements CalculatedValue<Long> {

        private Long value = null;

        @Override

        public void calculate() {

            JDBCStoreParameters params = getParameters();

            CountOperation count = getOperations().createCount(

                    getOperations().createTableReference(params),

                    params.getBaseFilter(), 

                    null

            );

            this.value = (Long) count.perform();            

        }

        @Override

        public void reset() {

            this.value = null;

        }

        @Override

        public Long get() {

            if( this.value == null ) {

                this.calculate();

            }

            return this.value;

        }

    } 

    public class EnvelopeValue implements CalculatedValue<Envelope> {

        private Envelope value = null;

        private boolean needCalculate = true;

        @Override

        public void calculate() {

            try {

                value = null;

                String columnName = getFeatureStore()

                        .getDefaultFeatureType()

                        .getDefaultGeometryAttributeName();

                if( columnName==null ) {

                    return;

                }

                IProjection crs = getFeatureStore()

                        .getDefaultFeatureType()

                        .getDefaultSRS();

                JDBCStoreParameters params = getParameters();

                CalculateEnvelopeOfColumnOperation calculateEnvelopeOfColumn = 

                    getOperations().createCalculateEnvelopeOfColumn(

                        getOperations().createTableReference(params),

                        columnName, 

                        params.getBaseFilter(), 

                        params.getWorkingArea(), 

                        crs

                    );

                value = (Envelope) calculateEnvelopeOfColumn.perform();

            } catch(Exception ex) {

                throw new RuntimeException("Can't calculate envelope.", ex);

            } finally {

               needCalculate = false;

            }

        }

        @Override

        public void reset() {

            this.value = null;

            this.needCalculate = true;

        }

        @Override

        public synchronized Envelope get() {

            if( needCalculate ) {

                this.calculate();

            }

            return this.value;

        }

    } 

    public class AllowWriteValue implements CalculatedValue<Boolean> {

        private Boolean value = null;

        @Override

        public void calculate() {

            try {

                JDBCStoreParameters params = getParameters();

                CanModifyTableOperation canModifyTable = 

                    getOperations().createCanModifyTableOperation(

                        getOperations().createTableReference(params)

                    );

                this.value = (boolean) canModifyTable.perform();

            } catch(Exception ex) {

                throw new RuntimeException("Can't determine if allow write.", ex);

            }

        }

        @Override

        public void reset() {

            this.value = null;

        }

        @Override

        public Boolean get() {

            if( this.value == null ) {

                this.calculate();

            }

            return this.value;

        }

    } 

    protected final JDBCHelper helper;

    protected CalculatedValue<Long> count = null;

    protected CalculatedValue<Envelope> envelope = null;

    protected CalculatedValue<Boolean> allowWrite = null;

    protected AppendOperation appendOperation = null;

    @SuppressWarnings({"OverridableMethodCallInConstructor", "CallToThreadStartDuringObjectConstruction"})

    protected JDBCStoreProviderBase(

            JDBCStoreParameters params,

            DataStoreProviderServices storeServices,

            DynObject metadata,

            JDBCHelper helper

    ) throws InitializeException {

        super(params, storeServices, metadata);

        this.helper = helper;

        this.initializeFeatureType();

        try {

            if( BooleanUtils.isTrue((Boolean) params.getDynValue("precalculateEnvelope"))  ) {

                FeatureType featureType = this.getStoreServices().getDefaultFeatureType();

                if( !StringUtils.isEmpty(featureType.getDefaultGeometryAttributeName()) ) {

                    Thread thread = new Thread(new Runnable() {

                        @Override

                        public void run() {

                            LOGGER.debug("Precalculating envelope of '"+getSourceId()+"'.");

                            getEnvelopeValue().get();

                        }

                    }, "PrecalculateEnvelopeOfDBTable");

                    thread.start();

                    Thread.sleep(1);

                }

           }

        } catch(Exception ex) {

            LOGGER.warn("Probems precalculating the envelope of table '"+this.getSourceId()+"'.", ex);

        }

    }

    @Override

    public JDBCSQLBuilderBase createExpression() {

        return this.getHelper().createSQLBuilder();

    }

    @Override

    public JDBCStoreParameters getParameters() {

        return (JDBCStoreParameters) super.getParameters();

    }  

    @Override

    public JDBCHelper getHelper() {

        return helper;

    }

    public OperationsFactory getOperations() {

        return this.getHelper().getOperations();

    }

    @Override

    public String getProviderName() {

        return this.getHelper().getProviderName();

    }

    @Override

    public int getOIDType() {

        return DataTypes.UNKNOWN;

    }

    @Override

    public Object createNewOID() {

        return null;

    }

    @Override

    public boolean allowAutomaticValues() {

        return this.getHelper().allowAutomaticValues();

    }

    @Override

    public boolean allowWrite() {

        return this.getAllowWriteValue().get();

    }

    @Override

    public Object getDynValue(String name) throws DynFieldNotFoundException {

        try {

            if (DataStore.METADATA_ENVELOPE.equalsIgnoreCase(name)) {

                Envelope env = this.getEnvelope();

                if (env != null) {

                    return env;

                }

            } else if (DataStore.METADATA_CRS.equalsIgnoreCase(name)) {

                IProjection proj;

                proj = this.getFeatureStore().getDefaultFeatureType().getDefaultSRS();

                if (proj != null) {

                    return proj;

                }

            }

        } catch (DataException e) {

            throw new RuntimeException(e);

        }

        return super.getDynValue(name);

    }

    @Override

    public CalculatedValue<Long> getCountValue() {

        if( this.count == null ) {

            this.count = new CountValue();

        }

        return this.count;

    }

    @Override

    public CalculatedValue<Envelope> getEnvelopeValue() {

        if( this.envelope == null ) {

            this.envelope = new EnvelopeValue();

        }

        return this.envelope;

    }

    @Override

    public CalculatedValue<Boolean> getAllowWriteValue() {

        if( this.allowWrite == null ) {

            this.allowWrite = new AllowWriteValue();

        }

        return this.allowWrite;

    }

    @Override

    public long getFeatureCount() throws DataException {

        return this.getCountValue().get();

    }

    @Override

    public boolean closeResourceRequested(ResourceProvider resource) {

        ResulSetControler resulSetControler = this.getHelper().getResulSetControler();

        resulSetControler.pack();

        return resulSetControler.getOpenCount() == 0;

    }

    @Override

    public void close() throws CloseException {

        JDBCUtils.closeQuietly(this.getHelper());

    }

    @Override

    public void resourceChanged(ResourceProvider resource) {

        this.getStoreServices().notifyChange(

                DataStoreNotification.RESOURCE_CHANGED,

                resource

        );

    }

    @Override

    public DataServerExplorer getExplorer() throws ReadException {

        DataManager manager = DALLocator.getDataManager();

        JDBCServerExplorerParameters exParams;

        JDBCStoreParameters params = getParameters();

        try {

            exParams = this.getHelper().createServerExplorerParameters();

            exParams.setHost(params.getHost());

            exParams.setPort(params.getPort());

            exParams.setDBName(params.getDBName());

            exParams.setUser(params.getUser());

            exParams.setPassword(params.getPassword());

            exParams.setUrl(params.getUrl());

            exParams.setCatalog(params.getCatalog());

            exParams.setSchema(params.getSchema());

            exParams.setJDBCDriverClassName(params.getJDBCDriverClassName());

            return manager.openServerExplorer(exParams.getExplorerName(), exParams);

        } catch (Exception e) {

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

        }

    }

    @Override

    protected void doDispose() throws BaseException {

        this.close();

        this.getHelper().dispose();

        super.doDispose();

    }

    @Override

    public String getSourceId() {

        try {

            return this.getHelper().getSourceId(this.getParameters());

        } catch(Exception ex) {

            return "unknow";

        }

    }

    @Override

    public String getName() {

        return this.getParameters().getTable();

    }

    @Override

    public String getFullName() {

        return this.getHelper().getSourceId(this.getParameters());

    }

    private static class DummyResource extends AbstractResource {

        private final String name;

        DummyResource(String name) throws InitializeException {

            super((ResourceParameters)null);

            this.name = name;

        }

        @Override

        public String getName() throws AccessResourceException {

            return MessageFormat.format("DummyResource({0})",

                                new Object[] { this.name });

        }

        @Override

        public Object get() throws AccessResourceException {

            return null;

        }

        @Override

        public boolean isThis(ResourceParameters parameters) throws ResourceException {

            return true;

        }

    }

    @Override

    public ResourceProvider getResource() {

        ResourceProvider r = getHelper().getResource();

        if( r == null ) {

            try {

                r = new DummyResource(this.getName());

            } catch (InitializeException ex) {

                LOGGER.warn("Can't create DummyResource",ex);

                // Do nothing

            }

        }

        return r;

    }

    @Override

    public void open() throws OpenException {

    }

    @Override

    public FeatureSetProvider createSet(

            FeatureQuery query,

            FeatureType featureType

        ) throws DataException {

        FeatureSetProvider set = new JDBCSetProvider(

                this,

                this.getHelper(), 

                query, 

                featureType

        );

        return set;

    }

    protected void initializeFeatureType() {

        EditableFeatureType type = this.getStoreServices().createFeatureType(getName());

        JDBCStoreParameters params = this.getParameters();

        List<String> primaryKeys = null;

        if( params.getPkFields() != null ) {

            primaryKeys = Arrays.asList(params.getPkFields());

        }

        FetchFeatureTypeOperation fetchFeatureType = 

             this.getOperations().createFetchFeatureType(

                type,

                this.getOperations().createTableReference(params),

                primaryKeys,

                params.getDefaultGeometryField(),

                params.getCRS()

            );

        fetchFeatureType.perform();

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

            if( !params.getDefaultGeometryField().equalsIgnoreCase(type.getDefaultGeometryAttributeName()) ) {

                type.setDefaultGeometryAttributeName(params.getDefaultGeometryField());

                EditableFeatureAttributeDescriptor attr = (EditableFeatureAttributeDescriptor) type.getDefaultGeometryAttribute();

                attr.setGeometryType(Geometry.TYPES.GEOMETRY, Geometry.SUBTYPES.GEOM2D);

            }

        }

        FeatureType defaultType = type.getNotEditableCopy();

        List<FeatureType> types = Collections.singletonList(defaultType);

        this.getStoreServices().setFeatureTypes(types, defaultType);

    }

    @Override

    protected FeatureProvider internalGetFeatureProviderByReference(

            FeatureReferenceProviderServices reference, 

            FeatureType featureType

        ) throws DataException {

        JDBCStoreParameters params = this.getParameters();

        FetchFeatureProviderByReferenceOperation fetchFeatureProviderByReference = 

            this.getOperations().createFetchFeatureProviderByReference(

                reference, 

                featureType, 

                this.getOperations().createTableReference(params)

            );

        FeatureProvider feature = (FeatureProvider) fetchFeatureProviderByReference.perform();

        return feature;

    }

    @Override

    public Envelope getEnvelope() throws DataException {

        return this.getEnvelopeValue().get();

    }

    @Override

    public void performChanges(Iterator deleteds, Iterator inserteds,

                    Iterator updateds, Iterator featureTypesChanged)

                    throws DataException {

        FeatureType type = this.getFeatureStore().getDefaultFeatureType();

        JDBCStoreParameters params = this.getParameters();

        PerformChangesOperation performChanges = this.getOperations().createPerformChanges(

                this.getOperations().createTableReference(params),

                type, 

                deleteds, 

                inserteds, 

                updateds, 

                featureTypesChanged

        );

        performChanges.perform();

        if( performChanges.isTypeChanged() ) {

            // Get rules before initializing feature type

            FeatureRules saved_rules = getFeatureStore().getDefaultFeatureType().getRules();

             // This initialization loses the feature type rules

            this.initializeFeatureType();

            // Get new feature type, clear rules and add the ones saved previously

            FeatureType featureType = getFeatureStore().getDefaultFeatureType();

            FeatureRules rules = featureType.getRules();

            rules.clear();

            for (FeatureRule rule : saved_rules) {

                rules.add(rule);

            }

        }

        this.getCountValue().reset();

        this.getEnvelopeValue().reset();

    }    

    @Override

    public boolean supportsAppendMode() {

        return true;

    }

    protected AppendOperation getAppendOperation() throws DataException {

        if( this.appendOperation == null ) {

            FeatureType type = this.getFeatureStore().getDefaultFeatureType();

            JDBCStoreParameters params = this.getParameters();

            this.appendOperation = this.getOperations().createAppend(

                this.getOperations().createTableReference(params),

                type 

            );

        }

        return this.appendOperation;

    }

    @Override

    public void endAppend() throws DataException {

        this.getAppendOperation().end();

    }

    @Override

    public void abortAppend() throws DataException {

        this.getAppendOperation().abort();

    }

    @Override

    public void beginAppend() throws DataException {

        this.getAppendOperation().begin();

    }

    @Override

    public void append(final FeatureProvider featureProvider) throws DataException {

        this.getAppendOperation().append(featureProvider);

    }    

    @Override

    public boolean canWriteGeometry(int geometryType, int geometrySubtype)

            throws DataException {

        return this.getHelper().canWriteGeometry(geometryType,geometrySubtype);

    }

}