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 org.gvsig.fmap.dal.store.jdbc2.JDBCServerExplorer;

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

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

import org.gvsig.fmap.dal.SQLBuilder;

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

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

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

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

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

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

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

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

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

import org.gvsig.json.Json;

import org.gvsig.json.JsonObjectBuilder;

import org.gvsig.tools.dispose.DisposeUtils;

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.resourcesstorage.EmptyResourcesStorage;

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, CachedValue<List<JDBCStoreParameters>>> 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 int cacheTime;

        private Map<String, String> mapping;

        public CustomResourcesConfig(String jsonConfig) {

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

            this.mapping = new HashMap<>();

            if (StringUtils.isNotBlank(jsonConfig)) {

                try {

                    JsonObject config = Json.createObject(jsonConfig);

                    this.cacheTime = config.getInt("CacheTime", 30*60);

                    if (!config.containsKey("Mapping")) {

                        JsonObject m = config.getJsonObject("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());

                            }

                        }

                    }

                } 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("cacheTime", cacheTime);

            JsonObjectBuilder m = Json.createObjectBuilder();

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

                String key = entry.getKey();

                String value = entry.getValue();

                m.add(key, value);

            }

            builder.add("mapping", m);

            return builder.build().toString();

        }

        public int getCacheExpireTimeInMillis() {

            return cacheTime;

        }

        public String getResourcesTablename(String tablename) {

            String resourceTablename = mapping.get(tablename);

            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;

        }

    }

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

            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 JDBCHelper helper;

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

            this.mode = mode;

            this.serverParameters = serverParameters;

            this.informationTables = informationTables;

            this.helper = helper;

        }

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

            this.mode = mode;

            this.setExpireTime(expireTime);

            this.serverParameters = serverParameters;

            this.informationTables = informationTables;

            this.helper = helper;

        }

        @Override

        protected void reload() {

            List<JDBCStoreParameters> tables = null;

            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

                );

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

            } catch (Exception ex) {

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

            }

            this.setValue(tables);

        }

    }

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

        DataStore store = super.open(params);

        return store;

    }

    @Override

    public List list(int mode) throws DataException {

        boolean informationTables = BooleanUtils.isTrue(

                this.getParameters().getShowInformationDBTables()

        );

        JDBCServerExplorerParameters serverParams = this.getParameters();

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

        CachedValue<List<JDBCStoreParameters>> tablesValue = CACHED_TABLES.get(key);

        List<JDBCStoreParameters> tables = null;

        if (tablesValue != null) {

            tables = tablesValue.get();

        }

        if (tables != null) {

            return tables;

        }

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

        CACHED_TABLES.put(key, tablesValue);

        tables = tablesValue.get();

        return tables;

    }

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

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

        clonedParams.setSchema(null); //ListTableOperation no usa el schema

        StringBuilder builder = new StringBuilder();

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

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

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

        String key = builder.toString();

        return key;

    }

    @Override

    public void remove(DataStoreParameters theParams) throws RemoveException {

        JDBCStoreParameters params = (JDBCStoreParameters) theParams;

        DropTableOperation removeTable = this.getOperations().createDropTable(

                this.getOperations().createTableReference(params)

        );

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

            this.dropCachedTables();

        }

    }

    @Override

    public JDBCStoreParameters getOpenParameters() throws DataException {

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

        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 {

        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 {

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

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

        return true;

    }

    private void dropCachedTables() {

        boolean informationTables = BooleanUtils.isTrue(

                this.getParameters().getShowInformationDBTables()

        );

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

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

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

    }

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

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

        return execute.perform();

    }

    @Override

    public JDBCStoreParameters get(String name) throws DataException {

        JDBCStoreParameters params = this.getOpenParameters();

        params.setTable(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);

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

        if (cachedConfig != null) {

            CustomResourcesConfig config = cachedConfig.get();

            return config;

        }

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

        cachedConfig = new CachedCustomResourcesConfig(params);

        CACHED_CUSTOM_RESOURCES_CONFIG.put(key, cachedConfig);

        return cachedConfig.get();

    }

    private ResourcesStorage getResourcesStorage(DataStoreParameters parameters, String storeName) {

        if (DatabaseWorkspaceManager.isInternalTable(storeName)) {

            EmptyResourcesStorage resourcesStorage = new EmptyResourcesStorage();

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

            }

            CustomResourcesConfig config = getCustomResourcesConfig();

            if( config!=null ) {

                if( config.isInternalTable(storeName) ) {

                    EmptyResourcesStorage theResourcesStorage = new EmptyResourcesStorage();

                    return theResourcesStorage;

                }

                resourcesTablename = config.getResourcesTablename(storeName);

                if( StringUtils.isNotBlank(resourcesTablename) ) {

                    JDBCStoreParameters params = this.getOpenParameters();

                    params.setTable(resourcesTablename);

                    JDBCResourcesStorage resourcesStorage = new JDBCResourcesStorage(

                            alternateResourcesStorage,

                            params,

                            storeName

                    );

                    return resourcesStorage;

                }

            }

            // 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)) {

                    JDBCResourcesStorage theResourcesStorage = new JDBCResourcesStorage(

                            alternateResourcesStorage,

                            params,

                            storeName

                    );

                    return theResourcesStorage;

                }

            }

        } catch (Throwable ex) {

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

        }

        EmptyResourcesStorage theResourcesStorage = new EmptyResourcesStorage();

        return theResourcesStorage;

    }

    @Override

    public ResourcesStorage getResourcesStorage() {

        JDBCStoreParameters params;

        try {

            params = this.getOpenParameters();

            params.setTable(DatabaseWorkspaceManager.TABLE_RESOURCES_NAME);

            JDBCResourcesStorage theResourcesStorage = new JDBCResourcesStorage(

                    null,

                    params,

                    "$ServerExplorer"

            );

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

        CustomResourcesConfig config = getCustomResourcesConfig();

        if( config==null ) {

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

        }

        config.addResourceMapping(tableName, resourcesTableName);

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

        setConfigValue(params, CONFIG_NAME_CUSTOM_RESOURCES, config.toJsonString());

    }

    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.warn("Can't write configuration value for '"+name+"'", ex);

            return false;

        } finally {

            DisposeUtils.disposeQuietly(store);

        }

    }

    private static String getConfigValue(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.warn("Can't read configuration value '"+name+"'", ex);

            return null;

        } finally {

            DisposeUtils.disposeQuietly(store);

        }

    }

}