/ - Diff - Application: gvSIG desktop - gvSIG

                     sqlbuilder.select().column().name(attr.getName());
                     columns.add(attr);
+                }
                 if( query !=null && query.isGrouped() ) {
                     sqlbuilder.select().group_by(expbuilder.column(attr.getName()));
+                }
+            }
             for(String attrName : forcedColumns ) {
                 sqlbuilder.select().column().name(attrName);
                 columns.add(setType.getAttributeDescriptor(attrName));
             if( query ==null || !query.isGrouped() ) {
                 for(String attrName : forcedColumns ) {
                     sqlbuilder.select().column().name(attrName);
                     columns.add(setType.getAttributeDescriptor(attrName));
+                }
+            }
             sqlbuilder.select().from().table()

     import org.gvsig.fmap.dal.exception.DataException;
     import org.gvsig.fmap.dal.feature.Feature;
     import org.gvsig.fmap.dal.feature.FeatureAttributeDescriptor;
     import org.gvsig.fmap.dal.feature.FeatureQuery;
     import org.gvsig.fmap.dal.feature.FeatureSet;
     import org.gvsig.fmap.dal.feature.FeatureStore;
     import org.gvsig.fmap.dal.feature.FeatureType;
-...
             final long timeLimit = System.currentTimeMillis() + limit * 1000;
             final DefaultComboBoxModel model = new DefaultComboBoxModel();
             this.setEnabled(false);
             final FeatureStore theStore = attribute.getFeatureStore();
             final FeatureQuery query = theStore.createFeatureQuery();
             query.addAttributeName(attribute.getDescriptor().getName());
             query.setGroup(true);
             query.setLimit(1000);
             Thread th = new Thread(new Runnable() {
                 @Override
                 public void run() {
                     try {
                         FeatureSet set = attribute.getFeatureStore().getFeatureSet();
                         FeatureSet set = theStore.getFeatureSet(query);
                         set.accept(new Visitor() {
                             @Override
                             public void visit(Object o) throws VisitCanceledException, BaseException {

     	 *            the load page size
     	 */
     	void setPageSize(long pageSize);
             void setGroup(boolean group);
             boolean isGrouped();
+    }

             rules.validate(feature, mode);
+        }
         public FeatureType getSubtype() throws DataException {
             return new SubtypeFeatureType(this, null, null, true);
+        }
         public FeatureType getSubtype(String[] names) throws DataException {
             if (names == null || names.length < 1) {
                 return (FeatureType) this.clone();
+            }
             return new SubtypeFeatureType(this, names, null);
             return this.getSubtype(names, null, true);
+        }
         public FeatureType getSubtype(String[] names, String[] constantsNames) throws DataException {
             return this.getSubtype(names, constantsNames, true);
+        }
         public FeatureType getSubtype(String[] names, String[] constantsNames, boolean includePk) throws DataException {
             if (ArrayUtils.isEmpty(names) && ArrayUtils.isEmpty(constantsNames)) {
                 return (FeatureType) this.clone();
+            }
             return new SubtypeFeatureType(this, names, constantsNames);
             return new SubtypeFeatureType(this, names, constantsNames,includePk);
+        }
         public FeatureType getSubtype() throws DataException {
             return new SubtypeFeatureType(this, null, null);
+        }
         public boolean isSubtypeOf(FeatureType featureType) {
             return false;
+        }
-...
             private static final long serialVersionUID = 6913732960073922540L;
             WeakReference parent;
             SubtypeFeatureType(DefaultFeatureType parent, String[] names, String[] constantsNames)
             SubtypeFeatureType(DefaultFeatureType parent, String[] names, String[] constantsNames, boolean includePk)
                     throws DataException {
                 super(parent, false);
                 DefaultFeatureAttributeDescriptor attrcopy;
-...
+                    }
+                }
                 // Add missing pk fiels
                 if (!parent.hasOID()) {
                 if (includePk && !parent.hasOID()) {
                     for (FeatureAttributeDescriptor attrdesc : parent) {
                         if (attrdesc.isPrimaryKey()) {
                             attrnames.add(attrdesc.getName());
-...
                 this.parent = new WeakReference(parent);
+            }
             public FeatureType getSubtype(String[] names) throws DataException {
             public FeatureType getSubtype(String[] names, boolean includePk) throws DataException {
                 return new SubtypeFeatureType((DefaultFeatureType) this.parent
                         .get(), names, null);
                         .get(), names, null, includePk);
+            }
             public boolean isSubtypeOf(FeatureType featureType) {

         @Override
         public Feature findFirst(FeatureQuery query) throws DataException {
             if( query == null ) {
                 query = this.createFeatureQuery();
             } else {
                 query = query.getCopy();
+            }
             query.setLimit(1);
             final MutableObject<Feature> feature = new MutableObject<>();
             try {
                 this.accept(new Visitor() {
-...
                 featureQuery.hasConstantsAttributeNames() ||
                 fType.hasRequiredFields()
                 ) {
                 return fType.getSubtype(featureQuery.getAttributeNames(), featureQuery.getConstantsAttributeNames() );
                 if( featureQuery.isGrouped() ) {
                     return fType.getSubtype(featureQuery.getAttributeNames(), featureQuery.getConstantsAttributeNames(), false );
                 } else {
                     return fType.getSubtype(featureQuery.getAttributeNames(), featureQuery.getConstantsAttributeNames());
+                }
+            }
             return fType;
+        }

     import java.util.HashMap;
     import java.util.List;
     import java.util.Map;
     import java.util.logging.Level;
     import java.util.logging.Logger;
     import org.apache.commons.lang3.ArrayUtils;
     import org.apache.commons.lang3.StringUtils;
     import org.gvsig.expressionevaluator.Expression;
     import org.gvsig.fmap.dal.DALLocator;
     import org.gvsig.fmap.dal.DataTypes;
     import org.gvsig.fmap.dal.exception.DataException;
     import org.gvsig.fmap.dal.exception.InitializeException;
     import org.gvsig.fmap.dal.feature.FeatureAttributeDescriptor;
     import org.gvsig.fmap.dal.feature.FeatureQuery;
     import org.gvsig.fmap.dal.feature.FeatureQueryOrder;
-...
         private long pageSize;
         private boolean group = false;
         /**
          * Creates a FeatureQuery which will load all available Features of a type.
+         *
-...
             this.constantsAttributeNames = new ArrayList();
+        }
         @Override
         public boolean isGrouped() {
             return this.group;
+        }
         @Override
         public void setGroup(boolean group) {
             this.group = group;
+        }
+    }

Application: gvSIG desktop

Revision 44374