/ - Diff - Application: gvSIG desktop - gvSIG

         public List<FeatureReference> getEditedFeaturesNotValidated() {
             return Collections.EMPTY_LIST;
+        }
         @Override
         public boolean isFeatureSelectionEmpty() {
             return false;
+        }
         @Override
         public boolean isFeatureSelectionAvailable() {
             return true;
+        }
+    }

trunk/org.gvsig.desktop/org.gvsig.desktop.compat.cdc/org.gvsig.fmap.dal/org.gvsig.fmap.dal.api/src/main/java/org/gvsig/fmap/dal/feature/FeatureQuery.java
355	355	*/
356	356	public void setVar(String name, Object value);
357	357
	358	public boolean hasLimit();
358	359	}

         public List<FeatureReference> getEditedFeatures();
         public List<FeatureReference> getEditedFeaturesNotValidated();
         public boolean isFeatureSelectionEmpty();
         public boolean isFeatureSelectionAvailable();
+    }

             @Override
             public SelectBuilder limit(Long limit) {
                 if (limit == null) {
                     this.limit = 0;
                     this.limit = -1;
                 } else {
                     this.limit = limit;
+                }
-...
             @Override
             public boolean has_limit() {
                 return this.limit > 0;
                 return this.limit >= 0;
+            }
             @Override

     import org.gvsig.fmap.dal.feature.impl.editing.memory.FeatureTypeManager;
     import org.gvsig.fmap.dal.feature.impl.editing.memory.SpatialManager;
     import org.gvsig.fmap.dal.feature.impl.featurereference.FeatureReferenceFactory;
     import org.gvsig.fmap.dal.feature.impl.featurereference.FeatureReferenceIteratorToFeatureIterator;
     import org.gvsig.fmap.dal.feature.impl.featureset.DefaultFeatureSet;
     import org.gvsig.fmap.dal.feature.impl.undo.DefaultFeatureCommandsStack;
     import org.gvsig.fmap.dal.feature.impl.undo.FeatureCommandsStack;
-...
             return selection;
+        }
         @Override
         public boolean isFeatureSelectionEmpty() {
             if( selection == null ) {
                 return true;
+            }
             return selection.isEmpty();
+        }
         //
         // ====================================================================
         // Gestion de notificaciones
-...
+        }
         public Iterator<Feature> getFeaturesIterator(Iterator<FeatureReference> references) {
             return new FeatureReferenceIteratorToFeatureIterator(this, references);
+        }
         public boolean isFeatureSelectionAvailable() {
             try {
                 FeatureType type = this.getDefaultFeatureType();
                 return type.supportReferences();
             } catch (DataException ex) {
                 return false;
+            }
+        }
+    }

         public DefaultFeatureQuery() {
             super();
             this.useSubquery = true; // true for backwards compatibility.
             this.limit = -1;
+        }
         public DefaultFeatureQuery(String storeName) {
-...
+        }
         @Override
         public boolean hasLimit() {
             return this.limit>-1;
+        }
         @Override
         public boolean hasOrder() {
             return this.order != null && this.order.size() > 0;
+        }

+        }
         private long calculateSize() throws DataException {
             boolean hasLimit = this.query.hasLimit();
             long limit = this.query.getLimit();
             long mySize = 0;
-...
                     return 0;
+                }
                 mySize = provider.getSize();
                 return (limit>0 && mySize>limit)? limit:mySize;
                 return (hasLimit && mySize>limit)? limit:mySize;
             case FILTERED:
             case ORDERED_FILTERED:
                 try {
                     iter = this.fastIterator();
                     while ((limit>0 && (mySize<limit)) || limit==0 ) {
                     while ((hasLimit && (mySize<limit)) || !hasLimit ) {
                         iter.next();
                         mySize++;
+                    }
-...
                 } finally {
                     DisposeUtils.disposeQuietly(iter);
+                }
                 return (limit>0 && mySize>limit)? limit:mySize;
                 return (limit>=0 && mySize>limit)? limit:mySize;
             case EDITED:
             case ORDERD_EDITED:
                 mySize = provider.getSize()
                     + store.getFeatureManager().getDeltaSize();
                 return (limit>0 && mySize>limit)? limit:mySize;
                 return (hasLimit && mySize>limit)? limit:mySize;
             case EDITED_FILTERED:
             case ORDERED_EDITED_FILTER:
                 try {
                     iter = this.fastIterator();
                     while ((limit>0 && (mySize<limit)) || limit==0 ) {
                     while ((hasLimit && (mySize<limit)) || !hasLimit ) {
                         iter.next();
                         mySize++;
+                    }
-...
                 } finally {
                     DisposeUtils.disposeQuietly(iter);
+                }
                 return (limit>0 && mySize>limit)? limit:mySize;
                 return (hasLimit && mySize>limit)? limit:mySize;
             default:
                 throw new IllegalArgumentException();

     import org.gvsig.fmap.dal.store.jdbc2.spi.operations.ListTablesOperation;
     import org.gvsig.fmap.dal.store.jdbc2.spi.operations.PerformChangesOperation;
     import org.gvsig.fmap.dal.store.jdbc2.spi.operations.ResultSetForSetProviderOperation;
     import org.gvsig.fmap.dal.store.jdbc2.spi.operations.RetrieveValueOperation;
     import org.gvsig.fmap.dal.store.jdbc2.spi.operations.TableIsEmptyOperation;
     import org.gvsig.fmap.dal.store.jdbc2.spi.operations.UpdatePassThroughOperation;
     import org.gvsig.fmap.dal.store.jdbc2.spi.operations.UpdateTableStatisticsOperation;
-...
                 Expression filter
         );
         public RetrieveValueOperation createRetrieveValue(
                 TableReference createTableReference,
                 String filter,
                 String order,
                 String fieldname
         );
+    }

     /**
      * 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.operations;
     import java.io.IOException;
     import java.sql.Blob;
     import java.sql.Clob;
     import java.sql.Connection;
     import java.sql.ResultSet;
     import java.sql.SQLException;
     import java.sql.Statement;
     import org.apache.commons.io.IOUtils;
     import org.gvsig.expressionevaluator.ExpressionBuilder;
     import org.gvsig.fmap.dal.SQLBuilder.SelectBuilder;
     import org.gvsig.fmap.dal.exception.DataException;
     import org.gvsig.fmap.dal.store.jdbc2.JDBCHelper;
     import org.gvsig.fmap.dal.store.jdbc2.spi.JDBCSQLBuilderBase;
     import org.gvsig.fmap.dal.store.jdbc.exception.JDBCSQLException;
     import org.gvsig.fmap.dal.store.jdbc2.JDBCUtils;
     import org.gvsig.fmap.dal.store.jdbc2.OperationsFactory.TableReference;
     public class RetrieveValueOperation extends AbstractConnectionOperation {
         private final TableReference table;
         private final String filter;
         private final String order;
         private final String fieldname;
         public RetrieveValueOperation(
                 JDBCHelper helper
             ) {
             this(helper, null, null, null, null);
+        }
         public RetrieveValueOperation(
                 JDBCHelper helper,
                 TableReference table,
                 String filter,
                 String order,
                 String fieldname
             ) {
             super(helper);
             this.table = table;
             this.filter = filter;
             this.order = order;
             this.fieldname = fieldname;
+        }
         @Override
         public final Object perform(Connection conn) throws DataException {
             return this.retrieveValue(conn);
+        }
         public String getSQL() {
             JDBCSQLBuilderBase sqlbuilder = this.createSQLBuilder();
             ExpressionBuilder expbuilder = sqlbuilder.expression();
             SelectBuilder select = sqlbuilder.select();
             select.column().name(this.fieldname);
             select.where().set(expbuilder.toValue(this.filter));
             // FIXME: Falta por ver de poner el order.
             select.from().table()
                     .database(this.table.getDatabase())
                     .schema(this.table.getSchema())
                     .name(this.table.getTable());
             String sql = select.toString();
             return sql;
+        }
         public Object retrieveValue(Connection conn) throws DataException {
             String sql = this.getSQL();
             Statement st = null;
             ResultSet rs = null;
             try {
                 st = conn.createStatement();
                 rs = JDBCUtils.executeQuery(st, sql);
                 if (!rs.next()) {
                     return null;
+                }
                 Object value = rs.getObject(1);
                 if (value instanceof Blob) {
                     Blob blob = (Blob) value;
                     value = blob.getBytes(1, (int) blob.length());
                     blob.free();
                 } else if (value instanceof Clob) {
                     Clob clob = (Clob) value;
                     value = new String(IOUtils.toCharArray(clob.getCharacterStream()));
                     clob.free();
+                }
                 return value;
             } catch (SQLException ex) {
                 throw new JDBCSQLException(ex,sql);
             } catch (IOException ex) {
                 throw new JDBCSQLException(ex,sql);
             } finally {
                 JDBCUtils.closeQuietly(st);
                 JDBCUtils.closeQuietly(rs);
+            }
+        }
+    }

             return new DeletePassThroughOperation(helper, table, filter);
+        }
         @Override
         public RetrieveValueOperation createRetrieveValue(
                 TableReference createTableReference,
                 String filter,
                 String order,
                 String fieldname) {
             return new RetrieveValueOperation(helper, createTableReference, filter, order, fieldname);
+        }
+    }

+                }
                 st = conn.createStatement();
                 st.setFetchSize(1);
                 rs = JDBCUtils.executeQuery(st, this.getSQLToRetrieveFirstRowOfTable());
                 rs = JDBCUtils.executeQuery(st, this.getSQLToRetrieveMetadataOfTable());
                 ResultSetMetaData rsMetadata = rs.getMetaData();
                 fetchFeatureTypeFromMetadata(conn, rsMetadata, pks);
-...
+            }
+        }
         public String getSQLToRetrieveFirstRowOfTable() {
         public String getSQLToRetrieveMetadataOfTable() {
           JDBCSQLBuilderBase sqlbuilder = this.createSQLBuilder();
           sqlbuilder.select().column().all();
           sqlbuilder.select().from().table()
-...
               .schema(this.table.getSchema())
               .name(this.table.getTable());
     //      sqlbuilder.select().from().subquery(this.table.getSubquery());
           sqlbuilder.select().limit(1);
           sqlbuilder.select().limit(0);
           String sql = sqlbuilder.toString();
           return sql;

                     String theTableName = params.getTable();
                     if (StringUtils.equals(theTableName, resourcesTablename)) {
                         defaultResourcesStorage = new JDBCResourcesStorage(
                                 this.helper,
                                 alternateResourcesStorage,
                                 params,
                                 storeName
-...
                             JDBCStoreParameters params = this.getOpenParameters();
                             params.setTable(resourcesTablename);
                             customResourcesStorage = new JDBCResourcesStorage(
                                     this.helper,
                                     alternateResourcesStorage,
                                     params,
                                     storeName,
-...
                 params = this.getOpenParameters();
                 params.setTable(DatabaseWorkspaceManager.TABLE_RESOURCES_NAME);
                 JDBCResourcesStorage theResourcesStorage = new JDBCResourcesStorage(
                         this.helper,
                         null,
                         params,
                         "$ServerExplorer"
-...
                     params = this.getOpenParameters();
                     params.setTable(resourcesTableName);
                     JDBCResourcesStorage resourcesStorage = new JDBCResourcesStorage(
                             this.helper,
                             null,
                             params,
                             tableName,

     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.exception.InitializeException;
     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.store.jdbc.JDBCStoreParameters;
     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.RetrieveValueOperation;
     import org.gvsig.tools.ToolsLocator;
     import org.gvsig.tools.dispose.DisposeUtils;
     import org.gvsig.tools.folders.FoldersManager;
-...
     public class JDBCResourcesStorage extends AbstractResourcesStorage {
         private static final Logger LOGGER = LoggerFactory.getLogger(JDBCResourcesStorage.class);
         private final JDBCHelper helper;
         private static class ExistsResourcesCache extends CachedValue<Map<String,Boolean>> {
             @Override
-...
                     return null;
+                }
+            }
             private byte[] retrieveResource() throws Exception {
                 ExpressionBuilder builder = ExpressionUtils.createExpressionBuilder();
                 String filter = builder.eq(
                         builder.column(FIELD_RESOURCES_NAME),
                         builder.constant(this.getTableName() + "." + this.name)
                 ).toString();
                 OperationsFactory operations = this.storage.helper.getOperations();
                 RetrieveValueOperation op = operations.createRetrieveValue(
                         operations.createTableReference(this.getStoreParameters()),
                         filter,
                         null, //order
                         FIELD_RESOURCES_RESOURCE
                 );
                 return (byte[] ) op.perform();
+            }
             private byte[] retrieveResource0() throws Exception {
                 FeatureStore store = null;
                 try {
                     DataManager dataManager = DALLocator.getDataManager();
                     store = (FeatureStore) dataManager.openStore(
                             this.getStoreParameters().getDataStoreName(),
                             this.getStoreParameters()
                     );
                     ExpressionBuilder builder = ExpressionUtils.createExpressionBuilder();
                     String filter = builder.eq(
                             builder.column(FIELD_RESOURCES_NAME),
                             builder.constant(this.getTableName() + "." + this.name)
                     ).toString();
                     Feature feature = store.findFirst(filter);
                     if (feature == null) {
                         return null;
+                    }
                     byte[] resource = feature.getByteArray(FIELD_RESOURCES_RESOURCE);
                     return resource;
                 } finally {
                     DisposeUtils.disposeQuietly(store);
+                }
+            }
             @Override
             public boolean exists() {
                 FeatureStore store = null;
     //            FeatureStore store = null;
                 try {
                     FoldersManager fm = ToolsLocator.getFoldersManager();
                     Pair<String, String> key = this.getCacheID();
-...
                     if( f.exists() ) {
                       return true;
+                    }
                     DataManager dataManager = DALLocator.getDataManager();
                     store = (FeatureStore) dataManager.openStore(
                             this.getStoreParameters().getDataStoreName(),
                             this.getStoreParameters()
                     );
                     ExpressionBuilder builder = ExpressionUtils.createExpressionBuilder();
                     String filter = builder.eq(
                             builder.column(FIELD_RESOURCES_NAME),
                             builder.constant(this.getTableName()+"."+this.name)
                     ).toString();
                     Feature feature = store.findFirst(filter);
                     boolean exists = feature!=null;
     //                DataManager dataManager = DALLocator.getDataManager();
     //                store = (FeatureStore) dataManager.openStore(
     //                        this.getStoreParameters().getDataStoreName(),
     //                        this.getStoreParameters()
     //                );
     //                ExpressionBuilder builder = ExpressionUtils.createExpressionBuilder();
     //                String filter = builder.eq(
     //                        builder.column(FIELD_RESOURCES_NAME),
     //                        builder.constant(this.getTableName()+"."+this.name)
     //                ).toString();
     //                Feature feature = store.findFirst(filter);
                     byte[] resource = retrieveResource();
                     boolean exists = resource!=null;
                     if( resource!=null ) {
                         putResourceInCache(resource);
+                    }
                     this.getExistsResourcesCache().put(key_s, exists);
                     return exists;
                 } catch (Throwable ex) {
                     LOGGER.warn("Can't access to the resoure '" + this.getURL() + "'.", ex);
                 } finally {
                     DisposeUtils.disposeQuietly(store);
     //            } finally {
     //                DisposeUtils.disposeQuietly(store);
+                }
                 return false;
+            }
-...
+              }
               return is;
+            }
             private void putResourceInCache(byte[] resource) {
                 FoldersManager fm = ToolsLocator.getFoldersManager();
                 Pair<String, String> key = this.getCacheID();
                 File f = fm.getTemporaryFile("resources-storage", "jdbc", key.getLeft(), key.getRight());
                 FileOutputStream os = null;
                 File f2 = null;
                 try {
                     FileUtils.forceMkdir(f.getParentFile());
                     os = new FileOutputStream(f);
                     IOUtils.write(resource, os);
                     IOUtils.closeQuietly(os);
                     f2 = fm.getTemporaryFile("resources-storage", "jdbc", key.getLeft(), "parameters");
                     byte[] data = this.getStoreParameters().toByteArray();
                     os = new FileOutputStream(f2);
                     IOUtils.write(data, os);
                 } catch (IOException ex) {
                     FileUtils.deleteQuietly(f);
                     FileUtils.deleteQuietly(f2);
                 } finally {
                     IOUtils.closeQuietly(os);
+                }
+            }
             private InputStream getInputStream() throws IOException {
                 FeatureStore store = null;
     //            FeatureStore store = null;
                 try {
                     DataManager dataManager = DALLocator.getDataManager();
                     store = (FeatureStore) dataManager.openStore(
                             this.getStoreParameters().getDataStoreName(),
                             this.getStoreParameters()
                     );
                     ExpressionBuilder builder = ExpressionUtils.createExpressionBuilder();
                     String filter = builder.eq(
                             builder.column(FIELD_RESOURCES_NAME),
                             builder.constant(this.getTableName()+"."+this.name)
                     ).toString();
                     Feature feature = store.findFirst(filter);
                     if (feature == null) {
                         return null;
+                    }
                     byte[] resource = feature.getByteArray(FIELD_RESOURCES_RESOURCE);
     //                DataManager dataManager = DALLocator.getDataManager();
     //                store = (FeatureStore) dataManager.openStore(
     //                        this.getStoreParameters().getDataStoreName(),
     //                        this.getStoreParameters()
     //                );
     //                ExpressionBuilder builder = ExpressionUtils.createExpressionBuilder();
     //                String filter = builder.eq(
     //                        builder.column(FIELD_RESOURCES_NAME),
     //                        builder.constant(this.getTableName()+"."+this.name)
     //                ).toString();
     //                Feature feature = store.findFirst(filter);
     //                if (feature == null) {
     //                    return null;
     //                }
     //                byte[] resource = feature.getByteArray(FIELD_RESOURCES_RESOURCE);
                     byte[] resource = retrieveResource();
                     InputStream is = new ByteArrayInputStream(resource);
                     return is;
                 } catch (Throwable ex) {
                     LOGGER.warn("Can't access to the resoure '" + this.getURL() + "'.", ex);
                 } finally {
                     DisposeUtils.disposeQuietly(store);
     //            } finally {
     //                DisposeUtils.disposeQuietly(store);
+                }
                 return null;
+            }
-...
+            }
+        }
         private final ResourcesStorage alternativeStorge;
         private final ResourcesStorage alternativeStorage;
         private final JDBCStoreParameters resourcesStoreParameters;
         private final String tableName;
         private final boolean readonly;
         private final ExistsResourcesCache existsResourcesCache;
         public JDBCResourcesStorage(
                     ResourcesStorage alternativeStorge,
                     JDBCHelper helper,
                     ResourcesStorage alternativeStorage,
                     JDBCStoreParameters resourcesStoreParameters,
                     String tableName
             ) {
             this(alternativeStorge, resourcesStoreParameters, tableName, false);
             this(helper, alternativeStorage, resourcesStoreParameters, tableName, false);
+        }
         public JDBCResourcesStorage(
                     ResourcesStorage alternativeStorge,
                     JDBCHelper helper,
                     ResourcesStorage alternativeStorage,
                     JDBCStoreParameters resourcesStoreParameters,
                     String tableName,
                     boolean readonly
             ) {
             this.helper = helper;
             this.readonly = readonly;
             this.alternativeStorge = alternativeStorge;
             this.alternativeStorage = alternativeStorage;
             if( StringUtils.equals(TABLE_RESOURCES_NAME, tableName) ) {
                 // No podemos buscar recursos de la tabla de recursos, ya que si no
                 // al abrise la tabla de recursos entraria en bucle.
-...
         @Override
         public Resource getResource(String name) {
             if( this.alternativeStorge!=null ) {
                 Resource r = this.alternativeStorge.getResource(name);
             if( this.alternativeStorage!=null ) {
                 Resource r = this.alternativeStorage.getResource(name);
                 if( r.exists() ) {
                     return r;
+                }
-...
             if (this.resourcesStoreParameters == null) {
                 return null;
+            }
             if( this.alternativeStorge!=null ) {
                 List<Resource> r = this.alternativeStorge.getResources(name);
             if( this.alternativeStorage!=null ) {
                 List<Resource> r = this.alternativeStorage.getResources(name);
                 if( r!=null && !r.isEmpty() ) {
                     return r;
+                }
-...
         @Override
         public boolean remove(String resourceName) {
             if( this.alternativeStorge!=null ) {
             if( this.alternativeStorage!=null ) {
                 try {
                     this.alternativeStorge.remove(resourceName);
                     this.alternativeStorage.remove(resourceName);
                 } catch (Exception e) {
                     //Do nothing
+                }

         );
         String retrieveFirstRowOfTableSQL = fetchFeatureType.getSQLToRetrieveFirstRowOfTable();
         String retrieveFirstRowOfTableSQL = fetchFeatureType.getSQLToRetrieveMetadataOfTable();
         String retrievePrimaryKeysFromInformationSchemaSQL = fetchFeatureType.getSQLToRetrievePrimaryKeysFromInformationSchema();
         System.out.println("Expected 0: ");
         System.out.println(expectedSQLs.get(0));

                 if (layer instanceof FLyrVect) {
                     try {
                         FeatureStore store = ((FLyrVect) layer).getFeatureStore();
                         if (store.getFeatureSelection().isAvailable()) {
                         if (store.isFeatureSelectionAvailable()) {
                             return true;
+                        }
                     } catch (Exception ex) {
-...
                 if (layer instanceof FLyrVect) {
                     try {
                         FeatureStore store = ((FLyrVect) layer).getFeatureStore();
                         FeatureSelection selection = store.getFeatureSelection();
                         if (!selection.isAvailable() || selection.isEmpty()) {
                         if (!store.isFeatureSelectionAvailable() || store.isFeatureSelectionEmpty()) {
                             return true;
+                        }
                         return false;

     import java.io.StringReader;
     import java.util.List;
     import java.util.function.Predicate;
     import java.util.logging.Level;
     import javax.swing.JOptionPane;
     import org.apache.commons.lang.mutable.MutableInt;
-...
     import org.gvsig.app.project.documents.view.ViewManager;
     import org.gvsig.fmap.dal.feature.EditableFeature;
     import org.gvsig.fmap.dal.feature.FeatureStore;
     import org.gvsig.fmap.geom.Geometry;
     import org.gvsig.fmap.mapcontext.MapContext;
     import org.gvsig.fmap.mapcontext.layers.FLayer;
     import org.gvsig.fmap.mapcontext.layers.vectorial.FLyrVect;
-...
     import org.gvsig.fmap.dal.feature.Feature;
     import org.gvsig.fmap.dal.feature.FeatureAttributeDescriptor;
     import org.gvsig.fmap.dal.feature.FeatureSelection;
     import org.gvsig.fmap.dal.feature.FeatureType;
     @SuppressWarnings({"UseSpecificCatch", "Convert2Lambda", "ConvertToTryWithResources"})
     public class PasteAlphanumericValuesFromClipboardExtension extends Extension {
         private static final Logger LOGGER = LoggerFactory.getLogger(PasteAlphanumericValuesFromClipboardExtension.class);
-...
+            }
             MapContext mapContext = viewdoc.getMapContext();
             List<FLayer> layers = mapContext.getLayers().getLayers(new Predicate<FLayer>() {
                 @Override
                 public boolean test(FLayer layer) {
                     return layer instanceof FLyrVect
                             && layer.isActive()
                             && layer.isAvailable()
                             && layer.isEditing();
+                }
             });
             List<FLayer> layers = mapContext.getLayers().getLayers((FLayer layer) -> layer instanceof FLyrVect
                     && layer.isActive()
                     && layer.isAvailable()
                     && layer.isEditing());
             if (layers.isEmpty()) {
                 return;
+            }
-...
+            }
             JsonObject fjson = (JsonObject) obj;
             try {
                 boolean hasPk = false;
                 FeatureType ft = store.getDefaultFeatureTypeQuietly();
                 for (String name : fjson.keySet()) {
                     FeatureAttributeDescriptor attr = ft.getAttributeDescriptor(name);
                     if( attr!=null ) {
                         if( attr.isPrimaryKey() ) {
                             hasPk = true;
                             break;
+                        }
+                    }
+                }
                 final boolean copyPk = hasPk && (application.confirmDialog(
                             i18n.getTranslation("_Copy_primary_key_values_XQuestionX"),
                             i18n.getTranslation("_Pasting_features_from_clipboard"),
                             JOptionPane.YES_NO_OPTION,
                             JOptionPane.QUESTION_MESSAGE,
                             "_CopyPrimaryKeyWhenPasteAlphanumericValuesFromClipboard"
                     ) == JOptionPane.YES_OPTION);
                 EditableFeature f = store.createNewFeature(fjson);
                 for (Feature selectionFeature : selectionFeatures) {
                     EditableFeature eds = selectionFeature.getEditable();
                     eds.copyFrom(f, new Predicate<FeatureAttributeDescriptor>() {
                         @Override
                         public boolean test(FeatureAttributeDescriptor attr) {
                             String nameGeom;
                             try {
-...
                             if (StringUtils.equals(attr.getName(), nameGeom)) {
                                 return false;
+                            }
                             if( !copyPk && attr.isPrimaryKey() ) {
                                 return false;
+                            }
                             return true;
+                        }
                     });
-...
             mapContext.invalidate();
+        }
         //metodo static para escribir en el store
         // pasteFromClipboard(FeatureStore store)
         // isValidClipboard()
         @Override
         public boolean isEnabled() {
             ApplicationManager application = ApplicationLocator.getManager();
-...
                         if (layer.isEditing()) {
                             numActiveVectorialEditable.increment();
+                        }
                         try {
                             if (!((FLyrVect) layer).getFeatureStore().getFeatureSelection().isEmpty()) {
                                 hasSelection.increment();
+                            }
                         } catch (DataException ex) {
                         if (!((FLyrVect) layer).getFeatureStore().isFeatureSelectionEmpty()) {
                             hasSelection.increment();
+                        }
+                    }
                     // No recuperamos ninguna capa, solo contamos las activa en edicion

                 return false;
+            }
             try {
                 FeatureSelection selection = layer.getFeatureStore().getFeatureSelection();
                 return !selection.isEmpty();
                 return !layer.getFeatureStore().isFeatureSelectionEmpty();
             } catch (Exception ex) {
                 LOGGER.warn("Can't get selection from layer '"+layer.getName()+"'.", ex);
                 return false;

     import javax.json.Json;
     import javax.json.JsonArray;
     import javax.json.JsonReader;
     import org.gvsig.fmap.dal.exception.DataException;
     import org.gvsig.fmap.dal.feature.FeatureAttributeDescriptor;
     import org.gvsig.fmap.dal.feature.FeatureType;
     public class PasteFeaturesFromClipboardExtension extends Extension {
-...
+            }
             FLyrVect layer = (FLyrVect) layers.get(0);
             FeatureStore store = layer.getFeatureStore();
             FeatureType ft = store.getDefaultFeatureTypeQuietly();
             boolean hasPk = false;
             if( !jsonArray.isEmpty() ) {
                 JsonObject fjson0 = (JsonObject) jsonArray.get(0);
                 for (String name : fjson0.keySet()) {
                     FeatureAttributeDescriptor attr = ft.getAttributeDescriptor(name);
                     if( attr!=null ) {
                         if( attr.isPrimaryKey() ) {
                             hasPk = true;
                             break;
+                        }
+                    }
+                }
+            }
             final boolean copyPk;
             if( hasPk ) {
                 int n = application.confirmDialog(
                         i18n.getTranslation("_Copy_primary_key_values_XQuestionX"),
                         i18n.getTranslation("_Pasting_features_from_clipboard"),
                         JOptionPane.YES_NO_OPTION,
                         JOptionPane.QUESTION_MESSAGE,
                         "_CopyPrimaryKeyWhenPasteFeaturesFromClipboard"
                 );
                 copyPk = ( n == JOptionPane.YES_OPTION );
             } else {
                 copyPk = false;
+            }
             List<EditableFeature> features = new ArrayList<>();
             FilteredLogger theLogger = new FilteredLogger(LOGGER, "PasteFeatures", 10);
             for (Object obj : jsonArray) {
-...
+                }
                 JsonObject fjson = (JsonObject) obj;
                 try {
                     EditableFeature f = store.createNewFeature(fjson);
                     EditableFeature f = store.createNewFeature(false);
                     f.copyFrom(fjson, new Predicate<FeatureAttributeDescriptor>() {
                         @Override
                         public boolean test(FeatureAttributeDescriptor attr) {
                             if( !copyPk && attr.isPrimaryKey() ) {
                                 return false;
+                            }
                             return true;
+                        }
                     });
                     features.add(f);
                 } catch (Exception ex) {
                     theLogger.warn("Can't create feature from JSON.", ex);

trunk/org.gvsig.desktop/org.gvsig.desktop.plugin/org.gvsig.app/org.gvsig.app.mainplugin/src/main/resources-plugin/i18n/text_en.properties
1524	1524	_Active_all_layers_of_group=Active all layers of group
1525	1525	_Inactive_all_layers_of_group=Inactive all layers of group
1526	1526	_Set_all_layers_of_group_to=Set all layers of group to
	1527	_Copy_primary_key_values_XQuestionX=Copy primary key values?

trunk/org.gvsig.desktop/org.gvsig.desktop.plugin/org.gvsig.app/org.gvsig.app.mainplugin/src/main/resources-plugin/i18n/text.properties
1608	1608	_Active_all_layers_of_group=Activar todas las capas del grupo
1609	1609	_Inactive_all_layers_of_group=Desactivar todas las capas del grupo
1610	1610	_Set_all_layers_of_group_to=Cambiar todas las capas del grupo a
	1611	_Copy_primary_key_values_XQuestionX=\u00bf Copiar los valores de la clave primaria ?

                     if ((layer instanceof FLyrVect) && layer.isAvailable() && layer.isActive()) {
                         FLyrVect layervect = (FLyrVect) layer;
                         usefulLayers.add(layervect);
                         try {
                             if (layervect.getFeatureStore().getFeatureSelection().isEmpty()) {
                                 emptySelectionLayers++;
+                            }
                         } catch (DataException e) {
                             logger.warn("Error While getting selection for layer '" + layer.getName() + "'.", e);
                             application.messageDialog(
                                     application.translate("Failed_selecting_layer") + ": " + layer.getName(),
                                     application.translate("Warning"),
                                     JOptionPane.WARNING_MESSAGE);
                         if (layervect.getFeatureStore().isFeatureSelectionEmpty()) {
                             emptySelectionLayers++;
+                        }
+                    }
+                }
-...
                 layer = layers[i];
                 if ((layer instanceof FLyrVect) && layer.isAvailable() && layer.isActive()) {
                     FLyrVect layervect = (FLyrVect) layer;
                     try {
                         if (!layervect.getFeatureStore().getFeatureSelection().isEmpty()) {
                             return true;
+                        }
                     } catch (DataException e) {
                         logger.warn("Error While getting selection for layer '" + layer.getName() + "'.", e);
                     if (!layervect.getFeatureStore().isFeatureSelectionEmpty()) {
                         return true;
+                    }
+                }
+            }

         private boolean thereIsSelection(FeatureTableDocumentPanel tabledoc) {
             if (tabledoc != null) {
                 try {
                     return !tabledoc.getModel().getStore()
                         .getFeatureSelection().isEmpty();
                 } catch (Exception e) {
                     logger.warn("Can't check if table has a selecction", e);
+                }
                 return !tabledoc.getModel().getStore().isFeatureSelectionEmpty();
+            }
             return false;

         );
         String retrieveFirstRowOfTableSQL = fetchFeatureType.getSQLToRetrieveFirstRowOfTable();
         String retrieveMetadataOfTableSQL = fetchFeatureType.getSQLToRetrieveMetadataOfTable();
         String retrievePrimaryKeysFromInformationSchemaSQL = fetchFeatureType.getSQLToRetrievePrimaryKeysFromInformationSchema();
         assertEquals("FetchFeatureType first row SQL", expectedSQLs.get(0), retrieveFirstRowOfTableSQL);
         assertEquals("FetchFeatureType SQL to retrieve metadata", expectedSQLs.get(0), retrieveMetadataOfTableSQL);
         assertEquals("FetchFeatureType get primery keys SQL", expectedSQLs.get(1), retrievePrimaryKeysFromInformationSchemaSQL);
+      }

trunk/org.gvsig.desktop/org.gvsig.desktop.plugin/org.gvsig.h2spatial/org.gvsig.h2spatial.h2gis132/org.gvsig.h2spatial.h2gis132.provider/src/test/resources/org/gvsig/fmap/dal/store/h2/fetchFeatureType.sql
1	1
2	2	-- FetchFeatureType first row SQL
3		SELECT * FROM "PUBLIC"."test" LIMIT 1;
	3	SELECT * FROM "PUBLIC"."test" LIMIT 0;
4	4
5	5	-- FetchFeatureType get primery keys SQL
6	6	SELECT

     		FeatureSet featureSet = null;
     		try {
     			taskStatus.message("Retrieve selection");
     			FeatureSelection selection = featureStore.getFeatureSelection();
                             FeatureSelection selection;
                             if( featureStore.isFeatureSelectionEmpty() ) {
                                 // No hay seleccion, asi que creamos una vacia que consuma pocos recursos.
                                 selection = featureStore.createMemoryFeatureSelection();
                             } else {
                                 // Ojo, que esta seleccion puede acabar haciendo un count(*) sobre la tabla.
                                 selection = featureStore.getFeatureSelection();
+                            }
     			if (featureQuery == null) {
     				featureQuery = featureStore.createFeatureQuery();

Application: gvSIG desktop

Revision 46277