Application: gvSIG desktop

            if( formatter!=null && formatter.canApply(this) ) {

                return formatter.format(this);

            }

        }

    }

    @Override

    public Constant geometry(Geometry geom, IProjection srs) {

    }

    @Override

    }

    @Override

        return ((GeometryExpressionBuilder)this.delegate).as_geometry(value);

    }

    public Constant srs(IProjection srs);

    public Function andand(Value geom1, Value geom2);

                                String.valueOf(builder.srs_id(geometry.getProjection()))

                        );

                    case NATIVE:

                                builder.bytearray_hex(GeometryUtils.toEWKB(geometry))

                        );

                    case WKT:

    }

    @Override

        return this.helper.as_geometry(value);

    }

                                this.getSRS()

                        );

                    case NATIVE:

                                this.builder.builder().bytearray_hex(

                                    GeometryUtils.toEWKB((Geometry) geometry)

                                )

    }

    protected GeometrySupportType geometrySupportType;

    public DefaultGeometryExpressionBuilderHelper(ExpressionBuilder builder) {

        this.builder = builder;

    @Override

    public Constant srs(IProjection projection) {

        if( projection == null ) {

        }

        return new ProjectionConstant(this, projection);

    }

    @Override

    public Constant geometry(Geometry geom, IProjection projection) {

        if( geom == null ) {

        }

        geom.setProjection(projection);

        return new GeometryConstant(this, geom);

    @Override

    public Constant geometry(Geometry geom) {

        if( geom == null ) {

        }

        if( geom.getProjection()==null ) {

            throw new IllegalArgumentException("The geometry does not have an associated projection. Use 'geometry(Geometry, IProjection)'.");

    @Override

    public Constant envelope(Envelope envelope, IProjection projection) {

        if( envelope == null ) {

        }

        Geometry geom = envelope.getGeometry();

        geom.setProjection(projection);

    @Override

    public Constant envelope(Envelope envelope) {

        if( envelope == null ) {

        }

        if( envelope.getProjection()==null ) {

            throw new IllegalArgumentException("The envelope does not have an associated projection. Use 'envelope(Geometry, IProjection)'.");

    }

    public Function builtin_function(String name, String format, Value... values) {

        func.format(format);

        return func;

    }    

    public Function function(String name, Value... values) {

        return func;

    }    

    @Override

        return builtin_function(FUNCTION_ST_ASBINARY, FORMAT_ST_ASBINARY, value);

    }

import org.gvsig.expressionevaluator.ExpressionUtils;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataTypes;

import org.gvsig.fmap.dal.NewDataStoreParameters;

import org.gvsig.fmap.dal.OpenDataStoreParameters;

            // restrictions if proceed.

            for (int i = 0; i < targetEditableFeatureType.size(); i++) {

                EditableFeatureAttributeDescriptor eAttr = (EditableFeatureAttributeDescriptor) targetEditableFeatureType.get(i);

                    eAttr.setIsPrimaryKey(false);

                    eAttr.setAllowNull(false);

                } else {

            // ======================================

            // Remove index to improve performance

            this.targetFeatureType = targetEditableFeatureType.getNotEditableCopy();

            }

            // ======================================

        EditableFeature targetFeature = null;

        FeatureStore target = null;

        Feature feature = null;

        try {

            ExportServiceManager serviceManager = ExportLocator.getServiceManager();

            ICoordTrans coord_trans = this.getParameters().getTransformationToUse();

            // ============================================

            JDBCServerExplorer explorer = this.createServerExplorer();

            if (this.getParameters().canCreatetable()) {

                LOG.debug("Creating table");

            }

            target.finishEditing();

                getTaskStatus().message("Preparing the update of the indices" + msgRowCount);

                target.edit();

                EditableFeatureType ft = target.getDefaultFeatureType().getEditable();

                );

            }

            LOG.info("Finish export");

            getTaskStatus().message("Exportation finished");

            getTaskStatus().terminate();

        } catch (Exception e) {

            LOG.warn("Can't export data.", e);

            getTaskStatus().message("Problems exporting data");

            throw new ExportException(e, targetFeature);

                }

                target.dispose();

            }

            this.getTaskStatus().terminate();

            this.getTaskStatus().remove();

        }

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.text.MessageFormat;

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

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

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

import org.gvsig.fmap.dal.DataServerExplorer;

import org.gvsig.fmap.dal.DataServerExplorerParameters;

import org.gvsig.fmap.dal.DataStoreParameters;

import org.gvsig.fmap.dal.DataTypes;

import org.gvsig.fmap.dal.DatabaseWorkspaceManager;

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

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

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

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

import org.gvsig.tools.dispose.DisposeUtils;

import org.gvsig.tools.dynobject.DynClass;

import org.gvsig.tools.dynobject.DynField;

    private static final String CONFIG_NAME_BASEFOLDER = "BASEFOLDER";

    private static final String CONFIG_NAME_ALTERNATIVE_RESOURCES_PATH = "ALTERNATIVE_RESOURCES_PATH";

    private class CachedConfigValue extends CachedValue<String> {

        private final String name;

    @Override

    public DataServerExplorer getServerExplorer() {

        try {

                    this.serverParameters.getProviderName(),

                    this.serverParameters

            );

            return server;

        } catch (Exception ex) {

            throw new RuntimeException("Can't get server explorer for workspace '"+Objects.toString(this.serverParameters)+"'", ex);

        }

    }

    private boolean existsTable(String tableName) {

        DataServerExplorer server = null;

        try {

            server = this.getServerExplorer();

            List<DataStoreParameters> list = server.list();

            if(list == null){

                return false;

            }

            for (DataStoreParameters params : server.list()) {

                String theTableName = (String) params.getDynValue("Table");

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

                    return true;

                }

            }

        } catch (Exception ex) {

            LOGGER.warn("Can't check if the table '"+tableName+"' exists.",ex);

        } finally {

            DisposeUtils.disposeQuietly(server);

        }

        return false;

    private FeatureStore getTable(String tableName) {

        DataServerExplorer server = null;

        try {

            DataManager dataManager = DALLocator.getDataManager();

            server = this.getServerExplorer();

            DataStoreParameters params = server.get(tableName);

            if( params!=null ) {

                FeatureStore store = (FeatureStore) dataManager.openStore(

                        params.getProviderName(), 

                        params,

                        true

                );

                return store;

            }

        } catch (Exception ex) {

            LOGGER.warn("Can't open table '"+tableName+"'.",ex);

        } finally {

            DisposeUtils.disposeQuietly(server);

        }

        return null;

    private void dropTable(String tableName) {

        DataServerExplorer server = null;

        try {

            server = this.getServerExplorer();

            DataStoreParameters params = server.get(tableName);

            if( params!=null ) {

                server.remove(params);

            }

        } catch (Exception ex) {

            LOGGER.warn("Can't drop table '"+tableName+"'.",ex);

        } finally {

            DisposeUtils.disposeQuietly(server);

        }

    }

        // la creacion de esta tabla en el helper de H2

        DataServerExplorer server = null;

        try {

            server = this.getServerExplorer();

            NewFeatureStoreParameters params = (NewFeatureStoreParameters) server.getAddParameters(tableName);

            EditableFeatureType ft = params.getDefaultFeatureType();

            ft.add(FIELD_RESOURCES_NAME, DataTypes.STRING, 150)

            ft.add(FIELD_RESOURCES_RESOURCE, DataTypes.BYTEARRAY)

                    .setAllowNull(true);

            server.add(tableName, params, false);

        } catch (Exception ex) {

            LOGGER.debug("Can't create resources table '"+tableName+"'.",ex);

            throw new RuntimeException("Can't create resources table '"+tableName+"'.", ex);

        } finally {

            DisposeUtils.disposeQuietly(server);

        }

    }

    @Override

    public void createTableRepository(String tableName) throws RuntimeException {

        DataServerExplorer server = null;

        try {

            server = this.getServerExplorer();

            NewFeatureStoreParameters params = (NewFeatureStoreParameters) server.getAddParameters(tableName);

            EditableFeatureType ft = params.getDefaultFeatureType();

            ft.add(FIELD_REPOSITORY_NAME, DataTypes.STRING, 150)

                    .setAllowNull(false)

                    .setDefaultValue(0);

            server.add(tableName, params, false);

        } catch (Exception ex) {

            LOGGER.debug("Can't create repository table '"+tableName+"'.",ex);

            throw new RuntimeException("Can't create repository table '"+tableName+"'.", ex);

        } finally {

            DisposeUtils.disposeQuietly(server);

        }

    }

        String tableName = TABLE_CONFIGURATION_NAME;

        DataServerExplorer server = null;

        FeatureStore store = null;

        try {

            server = this.getServerExplorer();

            NewFeatureStoreParameters params = (NewFeatureStoreParameters) server.getAddParameters(tableName);

            EditableFeatureType ft = params.getDefaultFeatureType();

            ft.add(FIELD_CONFIGURATION_NAME, DataTypes.STRING, 200)

            DataStoreParameters openParams = server.get(TABLE_CONFIGURATION_NAME);

            store = (FeatureStore) DALLocator.getDataManager().openStore(

            );

            store.edit();

            EditableFeature efeature = store.createNewFeature();

            store.finishEditing();                    

            this.existsConfiguration = null;

        } catch (Exception ex) {

            LOGGER.warn("Can't create table '"+tableName+"'.",ex);

        } finally {

            DisposeUtils.disposeQuietly(server);

            DisposeUtils.disposeQuietly(store);

        }

    @Override

    public String get(String name) {

        try {

                return null;

            }

            }

            }

            CachedConfigValue cachedValue = this.cachedConfigValues.get(name);

            }

            String value = this.getConfigValue(name);

            this.cachedConfigValues.put(name, new CachedConfigValue(name, value, 15000));

            value = ExpressionUtils.evaluateDynamicText(this, value);

            return value;

        } catch (Exception ex) {

            LOGGER.warn("Can't read configuration value '"+name+"'", ex);

            return null;

        }

    }

    private String getConfigValue(String name) {

        FeatureStore store = null;

        try {

            if( !this.existsConfiguration() ) {

                return null;

            }

            store = this.getTable(TABLE_CONFIGURATION);

            if( store == null ) {

                return null;

            }

            ExpressionBuilder builder = ExpressionUtils.createExpressionBuilder();

            String filter = builder.eq(

                    builder.column(FIELD_CONFIGURATION_NAME),

            ).toString();

            Feature feature = store.findFirst(filter);

            if( feature == null ) {

                return null;

            }

            String value = feature.getString(FIELD_CONFIGURATION_VALUE);

//            value = ExpressionUtils.evaluateDynamicText(this, value);

            return value;

        } catch (Exception ex) {

            LOGGER.warn("Can't read configuration value '"+name+"'", ex);

            return null;

        } finally {

            DisposeUtils.disposeQuietly(store);

        }

    }

    @Override

    public boolean set(String name, String value) {

        FeatureStore store = null;

        try {

            if( !this.existsConfiguration() ) {

                return false;

            }

            store = this.getTable(TABLE_CONFIGURATION);

            if( store == null ) {

                return false;

            }

            store.edit();

            ExpressionBuilder builder = ExpressionUtils.createExpressionBuilder();

            String filter = builder.eq(

                value = ExpressionUtils.evaluateDynamicText(this, value);

                this.cachedConfigValues.get(name).set(value);

            }

            return true;

        } catch (Exception ex) {

            LOGGER.warn("Can't write configuration value '"+name+"'", ex);

            return false;

        } finally {

            DisposeUtils.disposeQuietly(store);

        }

    }

    @Override

    public boolean writeStoresRepositoryEntry(String name, DataStoreParameters parameters) {

        FeatureStore store = null;

        try {

            parameters = this.replaceInFilesToUseBaseFolder(parameters);

            byte[] data = parameters.toByteArray();

            if( data == null ) {

                throw new RuntimeException("Can't convert parameters to byte array.");

            }

            store = this.getTable(TABLE_REPOSITORY);

            store.edit();

            ExpressionBuilder builder = ExpressionUtils.createExpressionBuilder();

            String filter = builder.eq(

            }

            store.finishEditing();

            this.storesRepository = null;

            return true;

        } catch (Exception ex) {

            LOGGER.warn("Can't save entry '"+name+"' in repository information", ex);

            return false;

        } finally {

            DisposeUtils.disposeQuietly(store);

        }

    }

    @Override

    public void create(String id, String description) {

            } else {

            }

        }

    }

    @Override

    public boolean exists(String name) {

        FeatureStore store = null;

        try {

            if( StringUtils.equalsIgnoreCase(name, "WORKSPACEFILE") ) {

                File wsfile = getWorkspaceFile();

                if( wsfile!=null ) {

                    return true;

                }

            }

            if (this.existsConfiguration()) {

              if( StringUtils.equalsIgnoreCase(name, CONFIG_NAME_BASEFOLDER) ) {

                return true;

              }

              if( this.cachedConfigValues.containsKey(name) ) {

                return true;

              }

              store = this.getTable(TABLE_CONFIGURATION);

              if (store != null) {

                  ExpressionBuilder builder = ExpressionUtils.createExpressionBuilder();

                  String filter = builder.eq(

                      String value = feature.getString(FIELD_CONFIGURATION_VALUE);

                      value = ExpressionUtils.evaluateDynamicText(this, value);

                      this.cachedConfigValues.put(name, new CachedConfigValue(name, value, 15000));

                      return true;

                  }

                }

            }

        } catch (Exception ex) {

            LOGGER.warn("Can't read configuration value '" + name + "'", ex);

            return false;

        } finally {

            DisposeUtils.disposeQuietly(store);

        }

    }

    @Override

    public Collection<String> localvariables() {

        FeatureStore store = null;

        try {

            final List<String> theVars = new ArrayList<>();

            if (this.existsConfiguration()) {

                store = this.getTable(TABLE_CONFIGURATION);

                    });

                }

            }

            return theVars;

        } catch (Exception ex) {

            LOGGER.warn("Can't read configuration variables", ex);

            return Collections.EMPTY_LIST;

        } finally {

            DisposeUtils.disposeQuietly(store);

        }

    }

    @Override

    public ResourcesStorage getResourcesStorage() {

        DataServerExplorer server = null;

        try {

            server = this.getServerExplorer();

            ResourcesStorage resourcesStorage = server.getResourcesStorage();

            return resourcesStorage;

        } catch (Exception ex) {

            LOGGER.warn("Can't get resorces storage.",ex);

            return null;

        } finally {

            DisposeUtils.disposeQuietly(server);

        }

    }

        return label;

    }

}

import java.util.Set;

import java.util.UUID;

import java.util.function.Predicate;

import javax.json.JsonArray;

import javax.json.JsonObject;

import javax.json.JsonValue;

import org.gvsig.fmap.dal.feature.paging.impl.FeaturePagingHelperImpl;

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

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

import org.gvsig.fmap.dal.feature.spi.cache.FeatureCacheProvider;

import org.gvsig.fmap.dal.feature.spi.cache.FeatureCacheProviderFactory;

import org.gvsig.fmap.dal.feature.spi.index.FeatureIndexProvider;

    }

    @Override

    public DataStore openStore(String providerName, DataStoreParameters parameters) throws InitializeException, ProviderNotRegisteredException, ValidateDataParametersException {

    }

    @Override

    public DataStore openStore(String providerName, DataStoreParameters parameters, boolean ignoreDALResource) throws InitializeException, ProviderNotRegisteredException, ValidateDataParametersException {

        if (providerName == null) {

            String msg = "Provider name can't be null.";

            LOGGER.warn(msg);

        DataStore store = (DataStore) storeFactory.create(parameters, this);

        if( store instanceof DefaultFeatureStore ) {

            ((DefaultFeatureStore)store).setIgnoreDALResource(ignoreDALResource);

        }

        DataStoreProvider provider = (DataStoreProvider) providerFactory.create(parameters, store);

                }

            }

        }

        try {

            ResourcesStorage resources = databaseWorkspace.getResourcesStorage();

            ScriptManager scriptManager = ToolsLocator.getScriptManager();

            Script script = scriptManager.loadScript(resources, "OnConnectToWorkspace.script");

            if( script != null ) {

                script.invokeFunction("main", new Object[] {databaseWorkspace});

            }

        } catch(Throwable th) {

            LOGGER.warn("Problems executing 'OnConnectToWorkspace.script' from workspace '"+databaseWorkspace.getId()+"'.",th);

        }

    }

import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.UUID;

import org.apache.commons.lang3.StringUtils;

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

    private boolean inProgress;

    private List<Disposable> disposables;

    private ObservableHelper observableHelper;

    public DefaultTransaction() {

        this.code = UUID.randomUUID().toString().replace("-", "");

        this.stores = new HashMap<>();

        this.explorers = new HashMap<>();

        this.disposables = new ArrayList<>();

        this.inProgress = false;

        this.connections = new HashMap<>();

        this.observableHelper = new ObservableHelper();

    @Override

    public void add(DataStore store, String id, boolean local) {

        String theId = id;

        if( StringUtils.isBlank(id) ) {

            theId = store.hashCode() + "@"+ store.getFullName();

    @Override

    public void add(DataServerExplorer explorer, String id, boolean local) {

        String theId = id;

        if( StringUtils.isBlank(id) ) {

            theId = String.valueOf(explorer.hashCode());

    }

    @Override

    public void remove(DataStore store) {

        if( this.inProgress && !DisposeUtils.isNullOrDisposed(store)){

            throw new IllegalStateException("Can't remove store from a in progress transaction.");

            }

            DisposeUtils.disposeQuietly(resource);            

        }

        for (ConnectionService connection : this.connections.values()) {

            connection.dispose();

        }

        this.disposables = null;

        this.stores = null;

    }

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

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

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

import org.gvsig.fmap.dal.feature.spi.cache.FeatureCacheProvider;

import org.gvsig.fmap.dal.feature.spi.index.FeatureIndexProviderServices;

import org.gvsig.fmap.dal.impl.DefaultDataManager;

import org.gvsig.tools.persistence.Persistent;

import org.gvsig.tools.persistence.PersistentState;

import org.gvsig.tools.persistence.exception.PersistenceException;

import org.gvsig.tools.resourcesstorage.ResourcesStorage;

import org.gvsig.tools.undo.RedoException;

import org.gvsig.tools.undo.UndoException;

        }

    }

    @Override

    synchronized public void finishEditing() throws DataException {

        LOGGER.debug("finish editing of mode: {}", mode);

        try {

            Map<String, List<FeatureAttributeDescriptor>> computedFields = this.getComputedFields();

            switch (mode) {

                    if (notifyChange(FeatureStoreNotification.BEFORE_FINISHEDITING).isCanceled()) {

                        return;

                    }

                    saveDALFile();

                    provider.endAppend();

                    exitEditingMode();

                    this.updateComputedFields(computedFields);

                    loadDALFile();

                    updateIndexes();

                    notifyChange(FeatureStoreNotification.AFTER_FINISHEDITING);

                    break;

                                featureManager.isSelectionCompromised()).isCanceled()) {

                            return;

                        }

                        saveDALFile();

                        if (featureManager.isSelectionCompromised() && selection != null) {

                            selection = null;

                        exitEditingMode();

                        loadDALFile();

                        updateIndexes();

                    } else {

                        exitEditingMode();

                    }

            }

        } catch (ValidateFeaturesException | WriteNotAllowedException ex) {

            // Don't notify failed.

            throw ex;

        } catch (PerformEditingException pee) {

            notifyChange(FeatureStoreNotification.FAILED_FINISHEDITING);

            throw new WriteException(provider.getSourceId().toString(), pee);

        } catch (Exception e) {

            notifyChange(FeatureStoreNotification.FAILED_FINISHEDITING);

            throw new FinishEditingException(e);

        }

    }

    @Override

    public String getEditingSession() {

        return this.editingSessionCode;

    @Override

    public void copyTo(final FeatureStore target) {

        boolean finishEditingAtEnd = false;

        try {

            if (!target.isEditing() && !target.isAppending()) {

                finishEditingAtEnd = true;

                target.edit(MODE_APPEND);

            if (finishEditingAtEnd) {

                target.finishEditing();

            }

        } catch (Exception ex) {

            try {

                }

            } catch (Exception ex1) {

            }

            throw new RuntimeException("Can't copy store.", ex);

        }

    }

    @Override

    public ResourcesStorage getResourcesStorage() {

        if (this.resourcesStorage != null) {

            DisposeUtils.bind(this.resourcesStorage);

            return this.resourcesStorage;

        }

            this.transaction.deleteObserver(transactionObserver);

        }

        this.transaction = transaction;

        }

        if( transaction!=null ) {

            transaction.addObserver(transactionObserver);

import junit.framework.TestCase;

import static junit.framework.TestCase.assertEquals;

import org.gvsig.fmap.dal.DatabaseWorkspaceManager;

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

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

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

import org.gvsig.tools.dispose.DisposeUtils;

import org.gvsig.tools.library.impl.DefaultLibrariesInitializer;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

            DisposeUtils.dispose(dbstore);

        } catch (Throwable th) {

            LOGGER.warn("", th);

            throw th;

        }

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataStore;

import static org.gvsig.fmap.dal.DataStore.H2SPATIAL_PROVIDER_NAME;

import org.gvsig.fmap.dal.DatabaseWorkspaceManager;

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

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

    public void insert_into_from(JDBCServerExplorer targetExplorer, String targetName, FeatureStore sourceStore, int mode) throws Exception {

        FeatureStore targetStore = openStore(targetExplorer, targetName);

        }

    }

                    0

            );

            String sql = resultSetForSetProvider.getSQL();

            assertEquals("ResultSetForSetProvider SQL", expectedSQLs.get(0), sql);

        } catch (Throwable th) {

            LOGGER.warn("", th);

import org.gvsig.expressionevaluator.ExpressionUtils;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

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

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

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

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

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

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

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

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

import org.gvsig.fmap.dal.store.jdbc.exception.SQLRuntimeException;

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

 * @author jjdelcerro

 */

@SuppressWarnings("UseSpecificCatch")

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

    public static final String TABLENAME_SERVER_EXPLORER_MARK = "$ServerExplorer";

    private final JDBCHelper helper;

    private static class ExistsResourcesCache extends CachedValue<Map<String,Boolean>> {

        @Override

        protected void reload() {

            try {

                DataManager dataManager = DALLocator.getDataManager();

                store = (FeatureStore) dataManager.openStore(

                        this.getStoreParameters().getDataStoreName(),

                        this.getStoreParameters()

                );

                }

                DataManager dataManager = DALLocator.getDataManager();

                store = (FeatureStore) dataManager.openStore(

                        this.getStoreParameters().getDataStoreName(),

                        this.getStoreParameters()

                );

                try {

                    DataManager dataManager = DALLocator.getDataManager();

                    store = (FeatureStore) dataManager.openStore(

                            this.getStoreParameters().getDataStoreName(),

                            this.getStoreParameters()

                    );

    }

    @Override

    public boolean isEmpty() {

        return this.resourcesStoreParameters == null;

    }

            DataManager dataManager = DALLocator.getDataManager();

            Set<String> typeNames = new HashSet<>();

            store = (FeatureStore) dataManager.openStore(

                    this.resourcesStoreParameters.getDataStoreName(),

                    this.resourcesStoreParameters

            );

        try {

            DataManager dataManager = DALLocator.getDataManager();

            store = (FeatureStore) dataManager.openStore(

                    this.resourcesStoreParameters.getDataStoreName(),

                    this.resourcesStoreParameters

            );

import org.gvsig.fmap.dal.DataServerExplorer;

import org.gvsig.fmap.dal.DataStore;

import org.gvsig.fmap.dal.DataStoreNotification;

import org.gvsig.fmap.dal.DataTypes;

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

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

            exParams.setCatalog(params.getCatalog());

            exParams.setSchema(params.getSchema());

            exParams.setJDBCDriverClassName(params.getJDBCDriverClassName());

        } catch (Exception e) {

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

        }

        try {

            String[] s = applicationAbbrev.split(":");

            sql = "select srid, auth_name, auth_srid from spatial_ref_sys where upper(auth_name) = upper('" + s[0] +"') and auth_srid = "+s[1]+" ";

            ResultSet rs = JDBCUtils.executeQuery(st, sql);

            if ( rs.next() ) {

                Integer srid = rs.getInt("srid");

    protected String searchApplicationAbbrev(JDBCConnection connection, Integer databaseCode) {

        String sql = "select srid, auth_name, auth_srid from spatial_ref_sys where srid = " + databaseCode;

        try {

            ResultSet rs = JDBCUtils.executeQuery(st, sql);

            if ( rs.next() ) {

                int auth_code = rs.getInt("auth_srid");

        Statement st = null;

        ResultSet rs = null;

        try {

            rs = JDBCUtils.executeQuery(st, sql);

            if (!rs.next()) {

                return null;

                            throw new JDBCTransactionRollbackException(e1, ex);

                        }

                        throw new SQLRuntimeException("Can't perform operation '"+this.getClass().getSimpleName()+"'.",ex);

                    } catch (Exception ex) {

                        try {

                            this.getConnection().rollback();

        Statement st = null;

        ResultSet rs = null;

        try {

            rs = JDBCUtils.executeQuery(st, sql);

            if (!rs.next()) {

                return 0;

        Statement st = null;

        String sql = getSQL(table, filter);

        try {

            JDBCUtils.executeUpdate(st, sql);

            JDBCUtils.closeQuietly(st);

            return null;

        Statement st = null;

        ResultSet rs = null;

        try {

            try {

                LOGGER.debug("execute query SQL:" + sql);

                rs = st.executeQuery(sql);

        Statement st = null;

        ResultSet rs = null;

        try {

            try {

                LOGGER.debug("execute query SQL:" + sql);

                rs = st.executeQuery(sql);

        Statement st = null;

        ResultSet rs = null;

        try {

            rs = JDBCUtils.executeQuery(st, sql);

            return !rs.next();