Application: gvSIG desktop

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2020 gvSIG Association.

 *

 * 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 3

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

 *

 * For any additional information, do not hesitate to contact us

 * at info AT gvsig.com, or visit our website www.gvsig.com.

 */

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

import java.text.MessageFormat;

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.apache.commons.lang3.builder.ToStringBuilder;

import org.cresques.cts.IProjection;

import org.gvsig.expressionevaluator.Expression;

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.expressionevaluator.FeatureAttributeEmulatorExpression;

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

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

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

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

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

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.FeatureSet;

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

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.spi.DataTransactionServices;

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.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.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.DeletePassThroughOperation;

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.dal.store.jdbc2.spi.operations.UpdatePassThroughOperation;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryUtils;

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

import org.gvsig.tools.dynobject.DynField;

import org.gvsig.tools.dynobject.DynObject;

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

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.observer.BaseNotification;

import org.gvsig.tools.observer.Observable;

import org.gvsig.tools.observer.Observer;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

@SuppressWarnings("UseSpecificCatch")

public class JDBCStoreProviderBase

        extends AbstractFeatureStoreProvider

        implements ResourceConsumer, JDBCStoreProvider {

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

    public class CountValue implements CalculatedValue<Long> {

        private Long value = null;

        @Override

        public void calculate() {

            try {

                JDBCStoreParameters params = getParameters();

                CountOperation count = getOperations().createCount(

                        getFeatureStore().getDefaultFeatureType(),

                        getOperations().createTableReference(params),

                        params.getBaseFilter(),

                        null

                );            

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

            } catch (DataException ex) {

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

            }

        }

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

            FeatureStore featureStore;

            FeatureType featureType;

            try {

                featureStore = getFeatureStore();

                if (featureStore == null) {

                    return;

                }

                featureType = featureStore.getDefaultFeatureType();

                if (featureType == null) {

                    return;

                }

            } catch (Exception ex) {

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

            }

            try {

                value = null;

                String columnName = featureType.getDefaultGeometryAttributeName();

                if( columnName==null ) {

                    return;

                }

                FeatureAttributeDescriptor attr = featureType.getAttributeDescriptor(columnName);

                boolean toDataBase = true;

                if(attr.isComputed()){

                    FeatureAttributeEmulator attrEmulator = attr.getFeatureAttributeEmulator();

                    if( !(attrEmulator instanceof FeatureAttributeEmulatorExpression) ) {

                        toDataBase = false;

                    } else {

                        FeatureAttributeEmulatorExpression x = (FeatureAttributeEmulatorExpression) attrEmulator;

                        Expression exp = x.getExpression();

                        if (exp == null || exp.isEmpty() ) {

                            toDataBase = false;

                        } else {

                            if (!helper.supportExpression(null, exp.getPhrase())) {

                                toDataBase = false;

                            }

                        }

                    }

                }

                if(toDataBase){

                    IProjection crs = getFeatureStore()

                            .getDefaultFeatureType()

                            .getDefaultSRS();

                    JDBCStoreParameters params = getParameters();

                    CalculateEnvelopeOfColumnOperation calculateEnvelopeOfColumn = 

                        getOperations().createCalculateEnvelopeOfColumn(

                            getFeatureStore().getDefaultFeatureType(),

                            getOperations().createTableReference(params),

                            columnName, 

                            params.getBaseFilter(), 

                            params.getWorkingArea(), 

                            crs

                        );

                    value = (Envelope) calculateEnvelopeOfColumn.perform(); 

                } else {

                    FeatureSet fset = getFeatureStore().getFeatureSet();

                    Envelope finalEnvelope = GeometryUtils.createEnvelope(Geometry.SUBTYPES.GEOM2D);

                    for (Feature feature : fset) {

                        Geometry geometry = feature.getGeometry(columnName);

                        finalEnvelope.add(geometry);

                    }

                    value = finalEnvelope;

                }

            } catch(Throwable 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;

    protected Observer transactionObserver;

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

                        LOGGER.trace("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);

        }

        this.transactionObserver = new Observer() {

            @Override

            public void update(Observable o, Object o1) {

                if( o1 instanceof BaseNotification && (

                        ((BaseNotification)o1).isOfType("ROLLBACK") ||

                        ((BaseNotification)o1).isOfType("COMMIT")

                        ) ) {

                    getCountValue().reset();

                    getEnvelopeValue().reset();

                }

            }

        };

    }

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

            DynField[] fields = exParams.getDynClass().getDynFields();

            for (DynField field : fields) {

                try {

                    exParams.setDynValue(field.getName(), params.getDynValue(field.getName()));

                } catch(Exception ex) {

                    // Ignore

                }

            }

            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 {

        if( this.helper.getTransaction()!=null ) {

            this.helper.getTransaction().deleteObserver(transactionObserver);

        }

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

                params.getGeometryType(),

                params.getGeometrySubtype()

            );

        fetchFeatureType.perform();

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

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

                if (type.getAttributeDescriptor(params.getDefaultGeometryField()) != null) {

                    type.setDefaultGeometryAttributeName(params.getDefaultGeometryField());

                } else {

                    type.setDefaultGeometryAttributeName(null);

                }

                if (type.getDefaultGeometryAttribute() != null) {

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

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

                }

            } else {

                type.setDefaultGeometryAttributeName(null);

            }

        }

        FeatureType defaultType = type.getNotEditableCopy();

        this.getHelper().setProviderFeatureType(defaultType);

        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,

                this.getStoreServices()

        );

        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 createAppendOperation() throws DataException {

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

        JDBCStoreParameters params = this.getParameters();

        AppendOperation theAppendOperation = this.getOperations().createAppend(

                this.getOperations().createTableReference(params),

                type 

        );

        return theAppendOperation;

    }

    @Override

    public void endAppend() throws DataException {

        this.appendOperation.end();

        this.getCountValue().reset();

        this.getEnvelopeValue().reset();

    }

    @Override

    public void abortAppend() throws DataException {

        this.appendOperation.abort();

    }

    @Override

    public void beginAppend() throws DataException {

        if( this.appendOperation == null ) {

            this.appendOperation = createAppendOperation();

        }

        this.appendOperation.begin();

    }

    @Override

    public void append(final FeatureProvider featureProvider) throws DataException {

        this.appendOperation.append(featureProvider);

    }    

    @Override

    public boolean canWriteGeometry(int geometryType, int geometrySubtype)

            throws DataException {

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

    }

    @Override

    public boolean supportsPassThroughMode() {

        return true;

    }

    @Override

    public void passThroughInsert(FeatureProvider featureProvider) throws DataException {

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

        JDBCStoreParameters params = this.getParameters();

        PerformChangesOperation performChanges = this.getOperations().createPerformChanges(

                this.getOperations().createTableReference(params),

                type, 

                Collections.emptyIterator(), 

                Collections.singletonList(featureProvider).iterator(),

                Collections.emptyIterator(), 

                Collections.emptyIterator(),

                this.getStoreServices()

        );

        performChanges.perform();

        this.getCountValue().reset();

        this.getEnvelopeValue().reset();

    }

    @Override

    public void passThroughUpdate(FeatureProvider featureProvider) throws DataException {

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

        JDBCStoreParameters params = this.getParameters();

        PerformChangesOperation performChanges = this.getOperations().createPerformChanges(

                this.getOperations().createTableReference(params),

                type, 

                Collections.emptyIterator(), 

                Collections.emptyIterator(), 

                Collections.singletonList(featureProvider).iterator(),

                Collections.emptyIterator(),

                this.getStoreServices()

        );

        performChanges.perform();

//        this.getCountValue().reset();

        this.getEnvelopeValue().reset();

    }

    @Override

    public void passThroughUpdate(Object[] parameters, Expression filter){

        JDBCStoreParameters params = this.getParameters();

        UpdatePassThroughOperation operation = this.getOperations().createUpdatePassThroughOperation(

                this.getOperations().createTableReference(params),

                parameters,

                filter

        );

        operation.perform();

//        this.getCountValue().reset();

        this.getEnvelopeValue().reset();

    }

    @Override

    public void passThroughDelete(FeatureReferenceProviderServices featureReference) throws DataException {

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

        JDBCStoreParameters params = this.getParameters();

        PerformChangesOperation performChanges = this.getOperations().createPerformChanges(

                this.getOperations().createTableReference(params),

                type, 

                Collections.singletonList(featureReference).iterator(),

                Collections.emptyIterator(), 

                Collections.emptyIterator(), 

                Collections.emptyIterator(),

                this.getStoreServices()

        );

        performChanges.perform();

        this.getCountValue().reset();

        this.getEnvelopeValue().reset();

    }

    @Override

    public void passThroughDelete(Expression expression) throws DataException {

        JDBCStoreParameters params = this.getParameters();

        DeletePassThroughOperation operation = this.getOperations().createDeletePassThroughOperation(

                this.getOperations().createTableReference(params),

                expression

        );

        operation.perform();

        this.getCountValue().reset();

        this.getEnvelopeValue().reset();

    }

    @Override

    public void setTransaction(DataTransactionServices transaction) {

        if( this.helper.getTransaction()!=null ) {

            this.helper.getTransaction().deleteObserver(transactionObserver);

        }

        this.helper.setTransaction(transaction);

        if( transaction!=null ) {

            transaction.addObserver(transactionObserver);

        }

    }

    @Override

    public String toString() {

        try {

            ToStringBuilder builder = new ToStringBuilder(this);

            builder.append("hash", String.format("%x", this.hashCode()));

            builder.append("helper", this.helper, true);

            return builder.toString();

        } catch (Exception e) {

            return super.toString();

        }

    }

    @Override

    public void refresh() throws OpenException {

        // Force to recalculare count, envelope and allowWrite

        this.count = null;

        this.envelope = null;

        this.allowWrite = null;

//        

//        if( this.helper.getResulSetControler().getOpenCount()>0 ) {

//            // Has ResultSetEntry open. Oh!!!!

//            this.helper.getResulSetControler().closeAll();

//        }

//        if( this.appendOperation!=null ) {

//            // Has and append operation in progress, Oh!!

//            this.appendOperation.abort();

//            this.appendOperation = null;

//        }

        super.refresh(); 

    }

}