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.io.File;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collections;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.Objects;

import javax.json.JsonObject;

import javax.json.JsonString;

import javax.json.JsonValue;

import org.apache.commons.codec.binary.Hex;

import org.apache.commons.collections.map.LRUMap;

import org.apache.commons.lang3.BooleanUtils;

import org.apache.commons.lang3.ObjectUtils;

import org.apache.commons.lang3.StringUtils;

import org.apache.commons.lang3.tuple.ImmutablePair;

import org.apache.commons.lang3.tuple.Pair;

import org.gvsig.expressionevaluator.ExpressionBuilder;

import org.gvsig.expressionevaluator.ExpressionUtils;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataStore;

import org.gvsig.fmap.dal.DataStoreParameters;

import org.gvsig.fmap.dal.DataTransaction;

import org.gvsig.fmap.dal.DatabaseWorkspaceManager;

import static org.gvsig.fmap.dal.DatabaseWorkspaceManager.FIELD_CONFIGURATION_NAME;

import static org.gvsig.fmap.dal.DatabaseWorkspaceManager.FIELD_CONFIGURATION_VALUE;

import static org.gvsig.fmap.dal.DatabaseWorkspaceManager.TABLE_CONFIGURATION_NAME;

import static org.gvsig.fmap.dal.DatabaseWorkspaceManager.TABLE_RESOURCES_NAME;

import org.gvsig.fmap.dal.NewDataStoreParameters;

import org.gvsig.fmap.dal.SQLBuilder;

import org.gvsig.fmap.dal.SQLBuilder.Privilege;

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

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

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

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

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

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

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

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

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

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

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

import org.gvsig.fmap.dal.serverexplorer.db.spi.AbstractDBServerExplorer;

import org.gvsig.fmap.dal.serverexplorer.filesystem.FilesystemStoreParameters;

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

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

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

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

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

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

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

import static org.gvsig.fmap.dal.store.jdbc2.spi.JDBCResourcesStorage.TABLENAME_SERVER_EXPLORER_MARK;

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

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

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

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

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

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

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

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

import org.gvsig.json.Json;

import org.gvsig.json.JsonObjectBuilder;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dispose.DisposeUtils;

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.resourcesstorage.ResourcesStorage;

import org.gvsig.tools.util.CachedValue;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

@SuppressWarnings("UseSpecificCatch")

public class JDBCServerExplorerBase extends AbstractDBServerExplorer implements JDBCServerExplorer {

    private static final Logger LOG = LoggerFactory.getLogger(JDBCServerExplorerBase.class);

    private static final String CONFIG_NAME_CUSTOM_RESOURCES = "CUSTOM_RESOURCES";

    protected JDBCHelper helper = null;

    private Boolean canAdd;

    private static final Map<String, CachedTablesValue> CACHED_TABLES = Collections.synchronizedMap(new LRUMap(10));

    private static final Map<String, CachedValue<CustomResourcesConfig>> CACHED_CUSTOM_RESOURCES_CONFIG = Collections.synchronizedMap(new LRUMap(10));

    private static class CustomResourcesConfig {

        private static final String CUSTOM_RESOURCES_CACHETIME = "CacheTime";

        private static final String CUSTOM_RESOURCES_MAPPING = "Mapping";

        private static final String CUSTOM_RESOURCES_READONLY = "ResourcesReadonly";

        private int cacheTime;

        private Map<String, String> mapping;

        private Map<String, Boolean> resourcesReadonly;

        public CustomResourcesConfig(String jsonConfig) {

            this.cacheTime = 30 * 60 * 1000; // 30min

            this.mapping = new HashMap<>();

            this.resourcesReadonly = new HashMap<>();

            if (StringUtils.isNotBlank(jsonConfig)) {

                try {

                    JsonObject config = Json.createObject(jsonConfig);

                    this.cacheTime = config.getInt(CUSTOM_RESOURCES_CACHETIME, this.cacheTime);

                    if (config.containsKey(CUSTOM_RESOURCES_MAPPING)) {

                        JsonObject m = config.getJsonObject(CUSTOM_RESOURCES_MAPPING);

                        for (Map.Entry<String, JsonValue> entry : m.entrySet()) {

                            String key = entry.getKey();

                            JsonValue value = entry.getValue();

                            if (value instanceof JsonString) {

                                this.mapping.put(key, ((JsonString) value).getString());

                            }

                        }

                    }

                    if (config.containsKey(CUSTOM_RESOURCES_READONLY)) {

                        JsonObject resreadonly = config.getJsonObject(CUSTOM_RESOURCES_READONLY);

                        for (Map.Entry<String, JsonValue> entry : resreadonly.entrySet()) {

                            String key = entry.getKey();

                            JsonValue value = entry.getValue();

                            if (value == JsonValue.TRUE) {

                                this.resourcesReadonly.put(key, true);

                            } else if (value == JsonValue.FALSE) {

                                this.resourcesReadonly.put(key, false);

                            }

                        }

                    }

                } catch (Exception ex) {

                    LOG.debug("Can't parse json from " + CONFIG_NAME_CUSTOM_RESOURCES + " variable", ex);

                    // Do nothing.

                }

            }

        }

        public String toJsonString() {

            JsonObjectBuilder builder = Json.createObjectBuilder();

            builder.add(CUSTOM_RESOURCES_CACHETIME, this.cacheTime);

            JsonObjectBuilder m = Json.createObjectBuilder();

            for (Map.Entry<String, String> entry : this.mapping.entrySet()) {

                String key = entry.getKey();

                String value = entry.getValue();

                m.add(key, value);

            }

            builder.add(CUSTOM_RESOURCES_MAPPING, m);

            JsonObjectBuilder resreadonly = Json.createObjectBuilder();

            for (Map.Entry<String, Boolean> entry : this.resourcesReadonly.entrySet()) {

                String key = entry.getKey();

                Boolean readonly = entry.getValue();

                resreadonly.add(key, readonly);

            }

            builder.add(CUSTOM_RESOURCES_READONLY, resreadonly);

            return builder.build().toString();

        }

        public int getCacheExpireTimeInMillis() {

            return cacheTime;

        }

        public String getResourcesTablename(String tablename) {

            String resourceTablename = mapping.get(tablename);

//            LOG.info("Resource of table "+tablename+" = "+resourceTablename);

            return resourceTablename;

        }

        public void addResourceMapping(String tablename, String resourcesTablename) {

            this.mapping.put(tablename, resourcesTablename);

        }

        private boolean isInternalTable(String storeName) {

            if (DatabaseWorkspaceManager.isInternalTable(storeName)) {

                return true;

            }

            for (String resourcesTablename : this.mapping.values()) {

                if (StringUtils.equals(storeName, resourcesTablename)) {

                    return true;

                }

            }

            return false;

        }

        public void setResourcesReadOnly(String resourcesTableName, boolean readonly) {

            this.resourcesReadonly.put(resourcesTableName, readonly);

        }

        public boolean isResourcesReadOnly(String resourcesTableName) {

            return this.resourcesReadonly.getOrDefault(resourcesTableName, false);

        }

    }

    private static class CachedCustomResourcesConfig extends CachedValue<CustomResourcesConfig> {

        private final JDBCStoreParameters openParameters;

        private CachedCustomResourcesConfig(JDBCStoreParameters openParameters) {

            this.openParameters = openParameters;

            this.setExpireTime(30 * 60 * 1000); // 30min

        }

        @Override

        protected void reload() {

            String jsonConfig = getConfigValue(this.openParameters, CONFIG_NAME_CUSTOM_RESOURCES);

//            LOGGER.info("reload CustomResourcesConfig "+jsonConfig);

            CustomResourcesConfig config = new CustomResourcesConfig(jsonConfig);

            this.setExpireTime(config.getCacheExpireTimeInMillis());

            this.setValue(config);

        }

    }

    private static class CachedTablesValue extends CachedValue<List<JDBCStoreParameters>> {

        private final int mode;

        private final JDBCServerExplorerParameters serverParameters;

        private final boolean informationTables;

        private final int tablesOrViews;

        public CachedTablesValue(JDBCHelper helper, int mode, JDBCServerExplorerParameters serverParameters, boolean informationTables, int tablesOrViews) {

            this.mode = mode;

            this.serverParameters = serverParameters;

            this.informationTables = informationTables;

            this.tablesOrViews = tablesOrViews;

        }

        public CachedTablesValue(JDBCHelper helper, int mode, JDBCServerExplorerParameters serverParameters, boolean informationTables, long expireTime, int tablesOrViews) {

            this.mode = mode;

            this.setExpireTime(expireTime);

            this.serverParameters = serverParameters;

            this.informationTables = informationTables;

            this.tablesOrViews = tablesOrViews;

        }

        @Override

        protected void reload() {

            throw new UnsupportedOperationException("Use get(helper) instead.");

        }

        protected void reload(JDBCHelper helper) {

//            LOGGER.info("reload list of tables");

            List<JDBCStoreParameters> tables = null;

            if (helper == null) {

                this.setValue(tables);

                return;

            }

            OperationsFactory operations = helper.getOperations();

            if (operations == null) {

                this.setValue(null);

                LOG.debug("Sets tables to null to force reload tables from new ServerExplorar.");

                return;

            }

            try {

                ListTablesOperation listTables = operations.createListTables(

                        this.mode, serverParameters, informationTables, tablesOrViews

                );

                tables = (List<JDBCStoreParameters>) listTables.perform();

                this.setValue(tables);

            } catch (Exception ex) {

                LOG.debug("Can't reload cached list of tables.", ex);

                throw new RuntimeException("Can't load list of tables", ex);

            }

        }

        public List<JDBCStoreParameters> get(JDBCHelper helper) {

            if (isExpired()) {

                this.reload(helper);

            }

            this.resetAccess();

            return this.getValue();

        }

    }

    public JDBCServerExplorerBase(

            JDBCServerExplorerParameters parameters,

            DataServerExplorerProviderServices services,

            JDBCHelper helper

    ) throws InitializeException {

        super(parameters, services);

        this.helper = helper;

    }

    @Override

    public String getProviderName() {

        return this.getHelper().getProviderName();

    }

    @Override

    public String getStoreName() {

        return this.getHelper().getProviderName();

    }

    protected DataManagerProviderServices getManager() {

        return (DataManagerProviderServices) DALLocator.getDataManager();

    }

    @Override

    public JDBCServerExplorerParameters getParameters() {

        return (JDBCServerExplorerParameters) super.getParameters();

    }

    @Override

    public boolean closeResourceRequested(ResourceProvider resource) {

        this.getHelper().getResulSetControler().pack();

        return true;

    }

    @Override

    public void resourceChanged(ResourceProvider resource) {

        // Nothing to do

    }

    protected JDBCHelper getHelper() {

        return helper;

    }

    protected OperationsFactory getOperations() {

        return this.getHelper().getOperations();

    }

    @Override

    public DataStore open(DataStoreParameters params) throws DataException {

        checkIsMine(params);

        try {

            DataStore store = getManager().openStore(this.getTransaction(), params.getProviderName(), params);

            return store;

        } catch (ValidateDataParametersException e) {

            throw new InitializeException(e);

        }

    }

    @Override

    public DataStore open(String tableName) throws DataException {

        JDBCStoreParameters params = this.get(tableName);

        try {

            DataStore store = getManager().openStore(this.getTransaction(), params.getProviderName(), params);

            return store;

        } catch (ValidateDataParametersException e) {

            throw new InitializeException(e);

        }

    }

    @Override

    public List list(int mode) throws DataException {

        return list(mode, SHOW_TABLES_AND_VIEWS);

    }

    @Override

    public List list(int mode, int tablesOrViews) throws DataException {

        LocalTransaction trans = new LocalTransaction(null, this.getTransaction());

        try {

            trans.begin();

            trans.add(this);

            boolean informationTables = BooleanUtils.isTrue(

                    this.getParameters().getShowInformationDBTables()

            );

            JDBCServerExplorerParameters serverParams = this.getParameters();

            String key = buildKeyForCachedTables(mode, serverParams, informationTables, tablesOrViews);

            CachedTablesValue tablesValue = CACHED_TABLES.get(key);

            List<JDBCStoreParameters> tables = null;

            if (tablesValue != null) {

                tables = tablesValue.get(this.helper);

            }

            if (tables != null) {

                return tables;

            }

            tablesValue = new CachedTablesValue(this.helper, mode, serverParams, informationTables, 60000, tablesOrViews); //60"

            CACHED_TABLES.put(key, tablesValue);

            tables = tablesValue.get(this.helper);

            trans.commit();

            return tables;

        } catch (Exception ex) {

            trans.abortQuietly();

            throw ex;

        } finally {

            trans.closeQuietly();

        }

    }

    public String buildKeyForCachedTables(int mode, JDBCServerExplorerParameters params, boolean informationTables, int tablesOrViews) {

        JDBCServerExplorerParameters clonedParams = (JDBCServerExplorerParameters) params.getCopy();

        clonedParams.setSchema(null);

        clonedParams.setCatalog(null);

        StringBuilder builder = new StringBuilder();

        builder.append(String.valueOf(mode));

        builder.append(Hex.encodeHex(clonedParams.toByteArray()));

        builder.append(String.valueOf(informationTables));

        builder.append(String.valueOf(tablesOrViews));

        String key = builder.toString();

        return key;

    }

    @Override

    public void remove(DataStoreParameters theParams) throws RemoveException {

        LocalTransaction trans = new LocalTransaction(null, this.getTransaction());

        try {

            trans.begin();

            trans.add(this);

            JDBCStoreParameters params = (JDBCStoreParameters) theParams;

            DropTableOperation removeTable = this.getOperations().createDropTable(

                    this.getOperations().createTableReference(params)

            );

            if ((Boolean) removeTable.perform()) {

                this.dropCachedTables();

            }

            trans.commit();

        } catch (RemoveException ex) {

            trans.abortQuietly();

            throw ex;

        } catch (Exception ex) {

            trans.abortQuietly();

            throw new RemoveException("Can't remove "+Objects.toString(theParams), ex);

        } finally {

            trans.closeQuietly();

        }

    }

    @Override

    public JDBCStoreParameters getOpenParameters() throws DataException {

        JDBCStoreParameters params = this.helper.createOpenStoreParameters(this.getParameters());

        if (StringUtils.isBlank(params.getSchema())) {

            params.setSchema(this.createSQLBuilder().default_schema());

        }

        return params;

    }

    @Override

    public NewDataStoreParameters getAddParameters(String storeName)

            throws DataException {

        JDBCNewStoreParameters params = this.getAddParameters();

        params.setTable(storeName);

        return params;

    }

    @Override

    public JDBCNewStoreParameters getAddParameters() throws DataException {

        JDBCServerExplorerParameters parameters = getParameters();

        JDBCNewStoreParameters params = this.helper.createNewStoreParameters();

        params.setHost(parameters.getHost());

        params.setPort(parameters.getPort());

        params.setDBName(parameters.getDBName());

        params.setUser(parameters.getUser());

        params.setPassword(parameters.getPassword());

        params.setCatalog(parameters.getCatalog());

        params.setSchema(parameters.getSchema());

        params.setJDBCDriverClassName(parameters.getJDBCDriverClassName());

        params.setUrl(parameters.getUrl());

        if (parameters instanceof FilesystemStoreParameters) {

            File f = ((FilesystemStoreParameters) parameters).getFile();

            ((FilesystemStoreParameters) params).setFile(f);

        }

        params.setDefaultFeatureType(this.getServerExplorerProviderServices()

                .createNewFeatureType());

        return params;

    }

    protected void checkIsMine(DataStoreParameters dsp) {

        if (!(dsp instanceof JDBCConnectionParameters)) {

            throw new IllegalArgumentException(

                    "not instance of FilesystemStoreParameters");

        }

        JDBCServerExplorerParameters parameters = getParameters();

        JDBCConnectionParameters pgp = (JDBCConnectionParameters) dsp;

        if (!StringUtils.equals(pgp.getHost(), parameters.getHost())) {

            throw new IllegalArgumentException("wrong explorer: Host (mine: "

                    + parameters.getHost() + " other:" + pgp.getHost() + ")");

        }

        if (!ObjectUtils.equals(pgp.getPort(), parameters.getPort())) {

            throw new IllegalArgumentException("wrong explorer: Port (mine: "

                    + parameters.getPort() + " other:" + pgp.getPort() + ")");

        }

        if (!StringUtils.equals(pgp.getDBName(), parameters.getDBName())) {

            throw new IllegalArgumentException("wrong explorer: DBName (mine: "

                    + parameters.getDBName() + " other:" + pgp.getDBName()

                    + ")");

        }

        if (!StringUtils.isEmpty(parameters.getCatalog())) {

            if (!StringUtils.equals(pgp.getCatalog(), parameters.getCatalog())) {

                throw new IllegalArgumentException(

                        "wrong explorer: Catalog (mine: "

                        + parameters.getCatalog() + " other:"

                        + pgp.getCatalog() + ")");

            }

        }

        if (!StringUtils.isEmpty(parameters.getSchema())) {

            if (!StringUtils.equals(pgp.getSchema(), parameters.getSchema())) {

                throw new IllegalArgumentException(

                        "wrong explorer: Schema (mine: "

                        + parameters.getSchema() + " other:"

                        + pgp.getSchema() + ")");

            }

        }

    }

    @Override

    public void open() throws OpenException {

    }

    @Override

    public void close() throws CloseException {

    }

    @Override

    protected void doDispose() throws BaseException {

        synchronized (CACHED_TABLES) {

            List<String> toRemove = new ArrayList<>();

//            for (Map.Entry<String, CachedValue<List<JDBCStoreParameters>>> entry : CACHED_TABLES.entrySet()) {

//                CachedTablesValue value = (CachedTablesValue) entry.getValue();

//                if (value.getHelper() == this.helper) {

//                    toRemove.add(entry.getKey());

//                    value.dispose();

//                }

//            }

//            for (String key : toRemove) {

//                CACHED_TABLES.remove(key);

//            }

            helper.dispose();

            helper = null;

        }

    }

    @Override

    public boolean canAdd() {

        if (this.canAdd == null) {

            CanCreateTablesOperation canAdd_ = this.getOperations().createCanCreateTables();

            this.canAdd = (Boolean) canAdd_.perform();

        }

        return this.canAdd;

    }

    @Override

    public FeatureType getFeatureType(DataStoreParameters theParams)

            throws DataException {

        JDBCStoreParameters params = (JDBCStoreParameters) theParams;

        checkIsMine(params);

        EditableFeatureType fetureType

                = this.getServerExplorerProviderServices().createNewFeatureType();

        List<String> primaryKeys = null;

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

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

        }

        FetchFeatureTypeOperation fetch = this.getOperations().createFetchFeatureType(

                fetureType,

                this.getOperations().createTableReference(params),

                primaryKeys,

                params.getDefaultGeometryField(),

                params.getCRS()

        );

        fetch.perform();

        return fetureType;

    }

    @Override

    public boolean add(String providerName, NewDataStoreParameters theParams, boolean overwrite)

            throws DataException {

        LocalTransaction trans = new LocalTransaction(null, this.getTransaction());

        try {

            trans.begin();

            trans.add(this);

            List<Pair<String, Privilege>> userAndPrivileges = new ArrayList<>();

            JDBCNewStoreParameters params = (JDBCNewStoreParameters) theParams;

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

                userAndPrivileges.add(

                        new ImmutablePair<>(params.getAllRole(), Privilege.ALL)

                );

            }

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

                userAndPrivileges.add(

                        new ImmutablePair<>(params.getDeleteRole(), Privilege.DELETE)

                );

            }

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

                userAndPrivileges.add(

                        new ImmutablePair<>(params.getInsertRole(), Privilege.INSERT)

                );

            }

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

                userAndPrivileges.add(

                        new ImmutablePair<>(params.getReferenceRole(), Privilege.REFERENCE)

                );

            }

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

                userAndPrivileges.add(

                        new ImmutablePair<>(params.getSelectRole(), Privilege.SELECT)

                );

            }

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

                userAndPrivileges.add(

                        new ImmutablePair<>(params.getTriggerRole(), Privilege.TRIGGER)

                );

            }

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

                userAndPrivileges.add(

                        new ImmutablePair<>(params.getTruncateRole(), Privilege.TRUNCATE)

                );

            }

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

                userAndPrivileges.add(

                        new ImmutablePair<>(params.getUpdateRole(), Privilege.UPDATE)

                );

            }

            List<String> additionalSQLs = new ArrayList<>();

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

                additionalSQLs.add(params.getPostCreatingStatement());

            }

            CreateTableOperation createTable = this.getOperations().createTable(

                    this.getOperations().createTableReference(params),

                    params.getDefaultFeatureType(),

                    userAndPrivileges,

                    additionalSQLs

            );

            boolean isOk = (boolean) createTable.perform();

            if (!isOk) {

                trans.commit();

                return false;

            }

            // We collect the featureType of the operation because 

            // the provider has been able to make changes to it

            params.setDefaultFeatureType(createTable.getType());

            if (theParams instanceof NewFeatureStoreParameters) {

                DataManager dataManager = DALLocator.getDataManager();

                ResourcesStorage resources = this.getResourcesStorage(theParams);

                dataManager.writeDALResource(resources, ((NewFeatureStoreParameters) theParams).getDefaultFeatureType());

            }

            this.dropCachedTables();

            trans.commit();

            return true;

        } catch (Exception ex) {

            trans.abortQuietly();

            throw ex;

        } finally {

            trans.closeQuietly();

        }

    }

    @Override

    public void dropCaches() {

        this.dropCachedTables();

    }

    private void dropCachedTables() {

        boolean informationTables = BooleanUtils.isTrue(

                this.getParameters().getShowInformationDBTables()

        );

        synchronized (CACHED_TABLES) {

            CACHED_TABLES.remove(buildKeyForCachedTables(MODE_ALL, this.getParameters(), informationTables, SHOW_TABLES_AND_VIEWS));

            CACHED_TABLES.remove(buildKeyForCachedTables(MODE_FEATURE, this.getParameters(), informationTables, SHOW_TABLES_AND_VIEWS));

            CACHED_TABLES.remove(buildKeyForCachedTables(MODE_GEOMETRY, this.getParameters(), informationTables, SHOW_TABLES_AND_VIEWS));

            CACHED_TABLES.remove(buildKeyForCachedTables(MODE_ALL, this.getParameters(), informationTables, SHOW_TABLES));

            CACHED_TABLES.remove(buildKeyForCachedTables(MODE_FEATURE, this.getParameters(), informationTables, SHOW_TABLES));

            CACHED_TABLES.remove(buildKeyForCachedTables(MODE_GEOMETRY, this.getParameters(), informationTables, SHOW_TABLES));

            CACHED_TABLES.remove(buildKeyForCachedTables(MODE_ALL, this.getParameters(), informationTables, SHOW_VIEWS));

            CACHED_TABLES.remove(buildKeyForCachedTables(MODE_FEATURE, this.getParameters(), informationTables, SHOW_VIEWS));

            CACHED_TABLES.remove(buildKeyForCachedTables(MODE_GEOMETRY, this.getParameters(), informationTables, SHOW_VIEWS));

        }

    }

    @Override

    public List getDataStoreProviderNames() {

        List x = new ArrayList(1);

        x.add(this.getProviderName());

        return x;

    }

    @Override

    public void updateTableStatistics(String database, String schema, String table) throws JDBCExecuteSQLException {

        UpdateTableStatisticsOperation updateStatistics = this.getOperations().createUpdateTableStatistics(

                this.getOperations().createTableReference(database, schema, table, null)

        );

        updateStatistics.perform();

    }

    @Override

    public Object execute(String sql) {

        LocalTransaction trans = new LocalTransaction(this.getManager(), getTransaction());

        try {

            trans.begin();

            trans.add(this);

            ExecuteOperation execute = this.getOperations().createExecute(sql);

            Object res = execute.perform();

            trans.commit();

            return res;

        } catch (RuntimeException ex) {

            trans.abortQuietly();

            throw ex;

        } catch (Exception ex) {

            trans.abortQuietly();

            throw new RuntimeException("Can't execute sql '"+sql+"'", ex);

        } finally {

            trans.closeQuietly();

        }

    }

    @Override

    public JDBCStoreParameters get(String name) throws DataException {

        JDBCStoreParameters params = this.getOpenParameters(name);

        return params;

    }

    @Override

    public SQLBuilder createSQLBuilder() {

        JDBCSQLBuilderBase builder = this.getHelper().createSQLBuilder();

        return builder;

    }

    private CustomResourcesConfig getCustomResourcesConfig() {

        JDBCServerExplorerParameters serverParams = this.getParameters();

        String key = buildKeyForCachedTables(MODE_ALL, serverParams, false, SHOW_TABLES_AND_VIEWS); //???

        CachedValue<CustomResourcesConfig> cachedConfig = CACHED_CUSTOM_RESOURCES_CONFIG.get(key);

        if (cachedConfig != null) {

//            LOG.info("Get CustomResourcesConfig from CACHE_1: "+!cachedConfig.isExpired());

            CustomResourcesConfig config = cachedConfig.get();

            return config;

        }

        JDBCStoreParameters params = this.helper.createOpenStoreParameters(this.getParameters());

        cachedConfig = new CachedCustomResourcesConfig(params);

        CACHED_CUSTOM_RESOURCES_CONFIG.put(key, cachedConfig);

//        LOG.info("Get CustomResourcesConfig from CACHE_2: "+!cachedConfig.isExpired());

        return cachedConfig.get();

    }

    private void refreshCustomResourcesConfig() {

        JDBCServerExplorerParameters serverParams = this.getParameters();

        String key = buildKeyForCachedTables(MODE_ALL, serverParams, false, SHOW_TABLES_AND_VIEWS); //???

        CachedValue<CustomResourcesConfig> cachedConfig = CACHED_CUSTOM_RESOURCES_CONFIG.get(key);

        if (cachedConfig != null) {

//            LOG.info("Force expire CustomResourcesConfig cache");

            cachedConfig.expired();

        }

    }

    private ResourcesStorage getResourcesStorage(DataStoreParameters parameters, String storeName) {

        if (DatabaseWorkspaceManager.isInternalTable(storeName)) {

            ResourcesStorage resourcesStorage = ResourcesStorage.EMPTY_RESOURCESSTORAGE;

            return resourcesStorage;

        }

        String resourcesTablename = null;

        try {

            ResourcesStorage alternateResourcesStorage = null;

            DataManager dataManager = DALLocator.getDataManager();

            DatabaseWorkspaceManager workspace = dataManager.getDatabaseWorkspace(parameters);

            if (workspace != null) {

                alternateResourcesStorage = workspace.getAlternativeResourcesStorage(storeName);

            }

            ResourcesStorage defaultResourcesStorage = null;

            ResourcesStorage customResourcesStorage = null;

            // TODO: Habria que ver de localizar los parametros sin tener que hacer un list.

            resourcesTablename = TABLE_RESOURCES_NAME;

            List<JDBCStoreParameters> tables = this.list();

            for (JDBCStoreParameters params : tables) {

                String theTableName = params.getTable();

                if (StringUtils.equals(theTableName, resourcesTablename)) {

                    defaultResourcesStorage = new JDBCResourcesStorage(

                            this.helper,

                            alternateResourcesStorage,

                            params,

                            storeName

                    );

                    break;

                }

            }

            CustomResourcesConfig config = getCustomResourcesConfig();

            if (config != null) {

                if (config.isInternalTable(storeName)) {

                    defaultResourcesStorage = ResourcesStorage.EMPTY_RESOURCESSTORAGE;

                } else {

                    resourcesTablename = config.getResourcesTablename(storeName);

                    if (StringUtils.isNotBlank(resourcesTablename)) {

                        JDBCStoreParameters params = this.getOpenParameters(resourcesTablename);

                        customResourcesStorage = new JDBCResourcesStorage(

                                this.helper,

                                alternateResourcesStorage,

                                params,

                                storeName,

                                config.isResourcesReadOnly(resourcesTablename)

                        );

                    }

                }

            }

            return new CompoundResourcesStorageWithSupportTransactions(defaultResourcesStorage, customResourcesStorage);

        } catch (Throwable ex) {

            LOG.warn("Can't retrieve reources storage for table '" + storeName + "' in '" + this.getParameters().getUrl() + " (" + resourcesTablename + ").", ex);

        }

        ResourcesStorage theResourcesStorage = ResourcesStorage.EMPTY_RESOURCESSTORAGE;

        return theResourcesStorage;

    }

    public ResourcesStorage getResourcesStorage(String name) {

        JDBCStoreParameters params;

        try {

            ResourcesStorage customResourcesStorage = null;

            CustomResourcesConfig config = getCustomResourcesConfig();

            if (config != null) {

                if (!config.isInternalTable(name)) {

                    String resourcesTablename = config.getResourcesTablename(name);

                    if (StringUtils.isNotBlank(resourcesTablename)) {

                        params = this.getOpenParameters(resourcesTablename);

                        customResourcesStorage = new JDBCResourcesStorage(

                                this.helper,

                                null,

                                params,

                                TABLENAME_SERVER_EXPLORER_MARK,

                                config.isResourcesReadOnly(resourcesTablename)

                        );

                    }

                }

            }

            params = this.getOpenParameters(DatabaseWorkspaceManager.TABLE_RESOURCES_NAME);

            JDBCResourcesStorage defaultResourcesStorage = new JDBCResourcesStorage(

                    this.helper,

                    null,

                    params,

                    TABLENAME_SERVER_EXPLORER_MARK

            );

            if (customResourcesStorage == null) {

                return defaultResourcesStorage;

            }

            return new CompoundResourcesStorageWithSupportTransactions(defaultResourcesStorage, customResourcesStorage);

        } catch (DataException ex) {

            return null;

        }

    }

    @Override

    public ResourcesStorage getResourcesStorage() {

        JDBCStoreParameters params;

        try {

            params = this.getOpenParameters(DatabaseWorkspaceManager.TABLE_RESOURCES_NAME);

//            params.setTable(DatabaseWorkspaceManager.TABLE_RESOURCES_NAME);

            JDBCResourcesStorage theResourcesStorage = new JDBCResourcesStorage(

                    this.helper,

                    null,

                    params,

                    TABLENAME_SERVER_EXPLORER_MARK

            );

            return theResourcesStorage;

        } catch (DataException ex) {

            return null;

        }

    }

    @Override

    public ResourcesStorage getResourcesStorage(DataStoreParameters parameters) {

        if (parameters == null) {

            throw new IllegalArgumentException("null is a valid value for parameters.");

        }

        String tableName;

        if (parameters instanceof JDBCNewStoreParameters) {

            tableName = ((JDBCNewStoreParameters) parameters).getTable();

        } else if (parameters instanceof JDBCStoreParameters) {

            tableName = ((JDBCStoreParameters) parameters).getTable();

        } else {

            throw new IllegalArgumentException("Required a JDBCStoreParameters or JDBCNewStoreParameters parameters, received " + parameters.getClass().getName() + ".");

        }

        return this.getResourcesStorage(parameters, tableName);

    }

    @Override

    public ResourcesStorage getResourcesStorage(DataStore dataStore) {

        return this.getResourcesStorage((JDBCStoreParameters) dataStore.getParameters(),

                dataStore.getName()

        );

    }

    @Override

    public boolean exists(DataStoreParameters parameters) throws DataException {

        JDBCStoreParameters params = (JDBCStoreParameters) parameters;

        JDBCSQLBuilderBase builder = this.getHelper().createSQLBuilder();

        SQLBuilder.TableNameBuilder searchTable = builder.createTableNameBuilder()

                .database(params.getDBName())

                .schema(params.getSchema())

                .name(params.getTable());

        SQLBuilder.TableNameBuilder table = builder.createTableNameBuilder();

        List<JDBCStoreParameters> l = this.list();

        for (JDBCStoreParameters current : l) {

            table.database(current.getDBName())

                    .schema(current.getSchema())

                    .name(current.getTable());

            if (table.equals(searchTable)) {

                return true;

            }

        }

        return false;

    }

    @Override

    public void setCustomResources(String tableName, String resourcesTableName) {

        this.setCustomResources(tableName, resourcesTableName, false);

    }

    @Override

    public void setCustomResources(String tableName, String resourcesTableName, boolean readonly) {

        CustomResourcesConfig config = getCustomResourcesConfig();

        if (config == null) {

            throw new RuntimeException("Can't retrieve alternative resources configuration");

        }

        config.addResourceMapping(tableName, resourcesTableName);

        config.setResourcesReadOnly(resourcesTableName, readonly);

        JDBCStoreParameters params = this.helper.createOpenStoreParameters(this.getParameters());

        if (!setConfigValue(params, CONFIG_NAME_CUSTOM_RESOURCES, config.toJsonString())) {

            throw new RuntimeException("Can't save custom resources configuration");

        }

        refreshCustomResourcesConfig();

        if (StringUtils.isNotBlank(resourcesTableName)) {

            try {

                params = this.getOpenParameters(resourcesTableName);

                JDBCResourcesStorage resourcesStorage = new JDBCResourcesStorage(

                        this.helper,

                        null,

                        params,

                        tableName,

                        config.isResourcesReadOnly(resourcesTableName)

                );

                resourcesStorage.clearCache();

            } catch (Exception ex) {

                LOG.debug("Can't remove local cache for table " + tableName, ex);

            }

        }

    }

    private static boolean setConfigValue(JDBCStoreParameters params, String name, String value) {

        FeatureStore store = null;

        try {

            DataManager dataManager = DALLocator.getDataManager();

            params.setTable(TABLE_CONFIGURATION_NAME);

            store = (FeatureStore) dataManager.openStore(

                    params.getProviderName(),

                    params

            );

        } catch (Exception ex) {

            LOG.trace("Can't read configuration value '" + name + "'", ex);

            // Do noting

//        } finally {

//            DisposeUtils.disposeQuietly(store);

        }

        if (store == null) {

            return false;

        }

        try {

            store.edit();

            ExpressionBuilder builder = ExpressionUtils.createExpressionBuilder();

            String filter = builder.eq(

                    builder.column(FIELD_CONFIGURATION_NAME),

                    builder.constant(name)

            ).toString();

            Feature feature = store.findFirst(filter);

            EditableFeature efeature;

            if (feature == null) {

                efeature = store.createNewFeature();

                efeature.set(FIELD_CONFIGURATION_NAME, name);

                efeature.set(FIELD_CONFIGURATION_VALUE, value);

                store.insert(efeature);

            } else {

                efeature = feature.getEditable();

                efeature.set(FIELD_CONFIGURATION_VALUE, value);

                store.update(efeature);

            }

            store.finishEditing();

            return true;

        } catch (Exception ex) {

            LOG.debug("Can't write configuration value for '" + name + "'", ex);

            return false;

        } finally {

            DisposeUtils.disposeQuietly(store);

        }

    }

//    private static String getConfigValue_useStore(JDBCStoreParameters params, String name) {

//        FeatureStore store = null;

//        try {

//            DataManager dataManager = DALLocator.getDataManager();

//            params.setTable(TABLE_CONFIGURATION_NAME);

//            store = (FeatureStore) dataManager.openStore(

//                    params.getProviderName(), 

//                    params

//            );

//        } catch (Exception ex) {

//            LOG.trace("Can't read configuration value '"+name+"'", ex);

//            // Do noting

////        } finally {

////            DisposeUtils.disposeQuietly(store);

//        }

//        if( store == null ) {

//            return null;

//        }

//        try {

//            ExpressionBuilder builder = ExpressionUtils.createExpressionBuilder();

//            String filter = builder.eq(

//                    builder.column(FIELD_CONFIGURATION_NAME),

//                    builder.constant(name)

//            ).toString();

//            Feature feature = store.findFirst(filter);

//            if( feature == null ) {

//                return null;

//            }

//            String value = feature.getString(FIELD_CONFIGURATION_VALUE);

//            return value;

//        } catch (Exception ex) {

//            LOG.debug("Can't read configuration value '"+name+"'", ex);

//            return null;

//        } finally {

//            DisposeUtils.disposeQuietly(store);

//        }

//    }

    private static String getConfigValue(JDBCStoreParameters params, String name) {

        JDBCServerExplorerBase explorer = null;

        DataManager dataManager = DALLocator.getDataManager();

        LocalTransaction trans = new LocalTransaction(dataManager, null);

        try {

            trans.begin();

            params.setTable(TABLE_CONFIGURATION_NAME);

            JDBCServerExplorerParameters explorerParams = (JDBCServerExplorerParameters) dataManager.createServerExplorerParameters(params.getProviderName());

            ToolsLocator.getDynObjectManager().copy(params, explorerParams);

            explorer = (JDBCServerExplorerBase) dataManager.openServerExplorer(explorerParams.getProviderName(), explorerParams);

            trans.add(explorer);

            ExpressionBuilder builder = ExpressionUtils.createExpressionBuilder();

            String filter = builder.eq(

                    builder.column(FIELD_CONFIGURATION_NAME),

                    builder.constant(name)

            ).toString();

            OperationsFactory operations = explorer.getOperations();

            RetrieveValueOperation op = operations.createRetrieveValue(

                    operations.createTableReference(params),

                    filter,

                    null, //order

                    FIELD_CONFIGURATION_VALUE

            );

            Object value = op.perform();

            trans.commit();

            return Objects.toString(value, null);

        } catch (Exception ex) {

            LOG.debug("Can't read configuration value '" + name + "'", ex);

            trans.abortQuietly();

            return null;

        } finally {

            trans.closeQuietly();

            DisposeUtils.disposeQuietly(explorer);

        }

    }

    @Override

    public boolean exists() {

        try {

            JDBCServerExplorerParameters serverParameters = this.getParameters();

            OperationsFactory operations = helper.getOperations();

            ListTablesOperation listTables = operations.createListTables(

                    MODE_ALL, serverParameters, false, SHOW_TABLES

            );

            List<JDBCStoreParameters> tables = (List<JDBCStoreParameters>) listTables.perform();

            return true;

        } catch (Throwable th) {

            return false;

        }

    }

    @Override

    public String getConnectionProviderStatus() {

        return this.helper.getConnectionProviderStatus();

    }

    public void setTransaction(DataTransaction transaction) {

        if (this.helper != null) {

            this.helper.setTransaction((DataTransactionServices) transaction);

        }

    }

    @Override

    public DataTransaction getTransaction() {

        if (this.helper == null) {

            return null;

        }

        return this.helper.getTransaction();

    }

    private JDBCStoreParameters getOpenParameters(String tableName) throws DataException {

        //No esta claro si se debe hacer este bucle o no. NO BORRAR ALEGREMENTE

//        List<JDBCStoreParameters> tables = this.list();

//        for (JDBCStoreParameters params : tables) {

//            String theTableName = params.getTable();

//            if (StringUtils.equals(theTableName, tableName)) {

//                return params;

//            }

//        }

        JDBCStoreParameters p = this.getOpenParameters();

        p.setTable(tableName);

        return p;

    }

}