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

import java.util.Map;

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

    protected JDBCHelper helper = null;

    private Boolean canAdd;

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

    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 ResourcesStorage getResourcesStorage(DataStoreParameters parameters, String storeName) {

        if( !DatabaseWorkspaceManager.isInternalTable(storeName) ) {

            ResourcesStorage alternateResourcesStorage = null;

            try {

                DataManager dataManager = DALLocator.getDataManager();

                DatabaseWorkspaceManager workspace = dataManager.getDatabaseWorkspace(parameters);

                if( workspace != null ) {

                    alternateResourcesStorage = workspace.getAlternativeResourcesStorage(storeName);

                }

            } catch(Throwable th) {

                alternateResourcesStorage = null;

            }

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

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

                for (JDBCStoreParameters params : tables) {

                    String theTableName = params.getTable();

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

                        JDBCResourcesStorage theResourcesStorage = new JDBCResourcesStorage(

                                alternateResourcesStorage,

                                params,

                                storeName

                        );

                        return theResourcesStorage;

                    }

                }

            } catch (Throwable ex) {

                LOG.warn("Can't retrieve reources storage from table '" + TABLE_RESOURCES_NAME + "' in '"+this.getParameters().getUrl()+"'.", 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;

    }

}