/trunk/org.gvsig.desktop/org.gvsig.desktop.compat.cdc/org.gvsig.fmap.dal/org.gvsig.fmap.dal.spi/src/main/java/org/gvsig/fmap/dal/feature/spi/SQLBuilderBase.java - Diff - Application: gvSIG desktop - gvSIG

Revision 44198 trunk/org.gvsig.desktop/org.gvsig.desktop.compat.cdc/org.gvsig.fmap.dal/org.gvsig.fmap.dal.spi/src/main/java/org/gvsig/fmap/dal/feature/spi/SQLBuilderBase.java

     import java.text.MessageFormat;
     import java.util.ArrayList;
     import java.util.Collection;
     import java.util.Collections;
     import java.util.HashMap;
     import java.util.HashSet;
-...
     import java.util.Map;
     import java.util.Objects;
     import java.util.Set;
     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.cresques.cts.IProjection;
     import org.gvsig.expressionevaluator.ExpressionBuilder;
     import static org.gvsig.expressionevaluator.ExpressionBuilder.Config.geometry_type_support;
     import static org.gvsig.expressionevaluator.ExpressionBuilder.Config.has_spatial_functions;
     import org.gvsig.expressionevaluator.ExpressionBuilder.AbstractValue;
     import org.gvsig.expressionevaluator.ExpressionBuilder.ClassVisitorFilter;
     import org.gvsig.expressionevaluator.ExpressionBuilder.GeometrySupportType;
     import org.gvsig.expressionevaluator.ExpressionBuilder.Parameter;
     import org.gvsig.expressionevaluator.ExpressionBuilder.Value;
     import org.gvsig.expressionevaluator.ExpressionBuilder.Variable;
     import org.gvsig.expressionevaluator.ExpressionBuilder.Visitable;
     import org.gvsig.expressionevaluator.ExpressionBuilder.Visitor;
     import org.gvsig.expressionevaluator.ExpressionBuilder.VisitorFilter;
     import org.gvsig.expressionevaluator.ExpressionEvaluatorLocator;
     import org.gvsig.expressionevaluator.Formatter;
     import org.gvsig.fmap.dal.DataStoreParameters;
     import org.gvsig.fmap.dal.DataTypes;
     import org.gvsig.fmap.dal.SQLBuilder;
-...
     import org.gvsig.fmap.dal.SQLBuilder.InsertColumnBuilder;
     import org.gvsig.fmap.dal.SQLBuilder.OrderByBuilder;
     import org.gvsig.fmap.dal.SQLBuilder.Privilege;
     import org.gvsig.fmap.dal.SQLBuilder.SQLConfig;
     import org.gvsig.fmap.dal.SQLBuilder.SelectBuilder;
     import org.gvsig.fmap.dal.SQLBuilder.SelectColumnBuilder;
     import org.gvsig.fmap.dal.SQLBuilder.TableNameBuilder;
-...
     import org.gvsig.fmap.dal.SQLBuilder.UpdateColumnBuilder;
     import org.gvsig.fmap.dal.SQLBuilder.UpdateTableStatisticsBuilder;
     import org.gvsig.fmap.dal.feature.FeatureAttributeDescriptor;
     import org.gvsig.fmap.dal.feature.FeatureStore;
     import org.gvsig.fmap.geom.Geometry;
     import org.gvsig.fmap.geom.primitive.Envelope;
     import org.slf4j.Logger;
     import org.slf4j.LoggerFactory;
     @SuppressWarnings("UseSpecificCatch")
     public class SQLBuilderBase implements SQLBuilder {
         protected static final Logger logger = LoggerFactory.getLogger(SQLBuilderBase.class);
         protected static final Logger LOGGER = LoggerFactory.getLogger(SQLBuilderBase.class);
         protected SelectBuilder select;
         protected UpdateBuilder update;
         protected InsertBuilder insert;
-...
         protected DropTableBuilder drop_table;
         protected UpdateTableStatisticsBuilder update_table_statistics;
         protected CreateIndexBuilder create_index;
         protected List<Parameter> parameters;
         public class ConfigBase implements Config {
         protected abstract class AbstractStatementPart extends AbstractValue {
             protected Map<String, Object> values;
             public ConfigBase() {
                 this.values = new HashMap<>();
+            }
             @Override
             public boolean has_functionality(String functionality) {
                 Object x = this.values.get(functionality);
                 if (x == null) {
                     return false;
+                }
                 if (x instanceof CharSequence && StringUtils.isEmpty((CharSequence) x)) {
                     return false;
+                }
                 return true;
+            }
             @Override
             public void remove_functionality(String functionality) {
                 this.values.remove(functionality);
+            }
             @Override
             public boolean has_spatial_functions() {
                 return this.getBoolean(has_spatial_functions);
+            }
             @Override
             public GeometrySupportType getGeometryTypeSupport() {
                 return (GeometrySupportType) this.get(geometry_type_support);
+            }
             @Override
             public boolean getBoolean(String name) {
                 return (boolean) this.values.get(name);
+            }
             @Override
             public String getString(String name) {
                 return (String) this.values.get(name);
+            }
             @Override
             public Object get(String name) {
                 return this.values.get(name);
+            }
             @Override
             public void set(String name, Object value) {
                 this.values.put(name, value);
+            }
+        }
         public abstract class AbstractValue implements Value {
         protected abstract class AbstractStatement extends AbstractStatementPart {
             @Override
             public void accept(Visitor visitor, VisitorFilter filter) {
                 if (filter == null || filter.accept(this)) {
                     visitor.visit(this);
+                }
+            }
+        }
         public class ClassVisitorFilter implements VisitorFilter {
             private final Class classFilter;
             public ClassVisitorFilter(Class classFilter) {
                 this.classFilter = classFilter;
+            }
             @Override
             public boolean accept(Visitable visitable) {
                 return classFilter.isInstance(visitable);
+            }
+        }
         public class GroupBase extends AbstractValue implements Group {
             protected Value value;
             public GroupBase(Value value) {
                 this.value = value;
+            }
             @Override
             public Value getValue() {
                 return value;
+            }
             @Override
             public void accept(Visitor visitor, VisitorFilter filter) {
                 super.accept(visitor, filter);
                 this.value.accept(visitor, filter);
+            }
             @Override
             public String toString() {
                 return MessageFormat.format(config.getString(Config.group), this.value.toString());
+            }
+        }
         protected class ColumnDescriptorBase implements ColumnDescriptor {
             private String name;
-...
                 this.geom_srsdbcode = null;
                 this._isIndexed = isIndexed;
+            }
             public ColumnDescriptorBase(String name, int geom_type, int geom_subtype, IProjection proj, boolean isIndexed, boolean allowNulls) {
                 this.name = name;
                 this.type = DataTypes.GEOMETRY;
-...
                 this.defaultValue = null;
                 this.geom_type = geom_type;
                 this.geom_subtype = geom_subtype;
                 this.geom_srsdbcode = getSRSId(proj);
                 this.geom_srsdbcode = srs_id(proj);
                 this._isIndexed = isIndexed;
+            }
             public ColumnDescriptorBase(String name, int geom_type, int geom_subtype, Object srsdbcode, boolean isIndexed, boolean allowNulls) {
                 this.name = name;
                 this.type = DataTypes.GEOMETRY;
-...
                 this.geom_srsdbcode = srsdbcode;
                 this._isIndexed = isIndexed;
+            }
             private ColumnDescriptorBase(FeatureAttributeDescriptor fad) {
                 this(fad.getName(), fad.getType(), fad.getDefaultValue());
                 this.type_p = fad.getPrecision();
                 this.type_s = fad.getSize();
                 this.isPk = fad.isPrimaryKey();
                 this._allowNulls = fad.allowNull();
                 this._isAutomatic = fad.isAutomatic();
                 this._isIndexed = fad.isIndexed();
                 if (fad.getType() == org.gvsig.fmap.geom.DataTypes.GEOMETRY) {
                     this.geom_type = fad.getGeomType().getType();
                     this.geom_subtype = fad.getGeomType().getSubType();
                     this.geom_srsdbcode = fad.getSRS();
+                }
+            }
             @Override
             public String getName() {
                 return this.name;
+            }
             @Override
             public void setName(String name) {
                 this.name = name;
-...
             @Override
             public void setGeometrySRSId(Object geom_srsid) {
                 this.geom_srsdbcode = geom_srsid;
+            }
+            }
             @Override
             public boolean isGeometry() {
-...
                 return this.parameters;
+            }
+        }
     //
     //    public class ColumnBase extends AbstractValue implements Column {
     //
     //        protected ColumnDescriptor descriptor;
     //        protected String name;
     //
     //        public ColumnBase(ColumnDescriptor descriptor) {
     //            this.name = descriptor.getName();
     //            this.descriptor = descriptor;
     //        }
     //
     //        public ColumnBase(String name) {
     //            this.name = name;
     //            this.descriptor = null;
     //        }
     //
     //        @Override
     //        public ColumnDescriptor getDescriptor() {
     //            return descriptor;
     //        }
     //
     //        @Override
     //        public String name() {
     //            return this.name;
     //        }
     //
     //        @Override
     //        public String toString() {
     //            return this.toString(formatter());
     //        }
     //
     //        @Override
     //        public String toString(Formatter<Value> formatter) {
     //            if (formatter.canApply(this)) {
     //                return formatter.format(this);
     //            }
     //            return as_identifier(this.name);
     //        }
     //
     //        @Override
     //        public int compareTo(ExpressionBuilder.Variable o) {
     //            return this.name.compareTo(o.name());
     //        }
     //
     //        @Override
     //        public boolean equals(Object obj) {
     //            if (!(obj instanceof ExpressionBuilder.Variable)) {
     //                return false;
     //            }
     //            return this.name.equals(((ExpressionBuilder.Variable) obj).name());
     //        }
     //
     //        @Override
     //        public int hashCode() {
     //            int hash = 7;
     //            hash = 37 * hash + Objects.hashCode(this.name);
     //            return hash;
     //        }
     //
     //    }
         public class VariableBase extends AbstractValue implements Column {
         public class TableNameBuilderBase
                 extends AbstractStatementPart
                 implements TableNameBuilder {
             protected ColumnDescriptor descriptor;
             protected String name;
             public VariableBase(ColumnDescriptor descriptor) {
                 this.name = descriptor.getName();
                 this.descriptor = descriptor;
+            }
             public VariableBase(String name) {
                 this.name = name;
                 this.descriptor = null;
+            }
             @Override
             public ColumnDescriptor getDescriptor() {
                 return descriptor;
+            }
             @Override
             public String getName() {
                 return this.name;
+            }
             @Override
             public String toString() {
                 return identifier(this.name);
+            }
             @Override
             public int compareTo(ExpressionBuilder.Variable o) {
                 return this.name.compareTo(o.getName());
+            }
             @Override
             public boolean equals(Object obj) {
                 if (!(obj instanceof ExpressionBuilder.Variable)) {
                     return false;
+                }
                 return this.name.equals(((ExpressionBuilder.Variable) obj).getName());
+            }
             @Override
             public int hashCode() {
                 int hash = 7;
                 hash = 37 * hash + Objects.hashCode(this.name);
                 return hash;
+            }
+        }
         public class ParameterBase extends AbstractValue implements Parameter {
             protected String name;
             protected Object value;
             protected ParameterType type;
             protected Value srs;
             public ParameterBase() {
                 this.type = ParameterType.Constant;
                 this.name = null;
                 this.value = null;
+            }
             @Override
             public void accept(Visitor visitor, VisitorFilter filter) {
                 super.accept(visitor, filter);
                 if (this.srs != null) {
                     this.srs.accept(visitor, filter);
+                }
+            }
             @Override
             public Parameter as_geometry_variable() {
                 this.type = ParameterType.Geometry;
                 if (this.value == null && this.name != null) {
                     this.value = this.name;
+                }
                 return this;
+            }
             @Override
             public Parameter as_constant() {
                 this.type = ParameterType.Constant;
                 if (this.value == null && this.name != null) {
                     this.value = this.name;
+                }
                 return this;
+            }
             @Override
             public Parameter as_variable() {
                 this.type = ParameterType.Variable;
                 if (this.value != null && this.name == null) {
                     this.name = (String) this.value;
+                }
                 return this;
+            }
             @Override
             public Parameter srs(Value srs) {
                 this.srs = srs;
                 if( this.type == ParameterType.Variable ) {
                     this.type = ParameterType.Geometry;
+                }
                 return this;
+            }
             @Override
             public Parameter srs(IProjection srs) {
                 this.srs = constant(getSRSId(srs));
                 if( this.type == ParameterType.Variable ) {
                     this.type = ParameterType.Geometry;
+                }
                 return this;
+            }
             @Override
             public String getName() {
                 switch (this.type) {
                     case Variable:
                     case Geometry:
                         return this.name;
                     case Constant:
                         if (this.value == null) {
                             return null;
+                        }
                         return this.value.toString();
                     default:
                         if (this.name != null) {
                             return this.name;
+                        }
                         if (this.value != null) {
                             return this.value.toString();
+                        }
                         return null;
+                }
+            }
             @Override
             public boolean is_constant() {
                 return this.type == ParameterType.Constant;
+            }
             @Override
             public boolean is_geometry_variable() {
                 return this.type == ParameterType.Geometry;
+            }
             @Override
             public boolean is_variable() {
                 return this.type == ParameterType.Variable;
+            }
             @Override
             public Parameter value(Object value) {
                 this.value = value;
                 return this;
+            }
             @Override
             public Parameter name(String name) {
                 this.type = ParameterType.Variable;
                 this.name = name;
                 return this;
+            }
             @Override
             public Object getValue() {
                 try {
                     switch (this.type) {
                         case Constant:
                             if (this.value instanceof Geometry) {
                                 switch (config.getGeometryTypeSupport()) {
                                     case EWKB:
                                         return bytearray(((Geometry) this.value).convertToEWKB());
                                     case NATIVE:
                                     case WKB:
                                         return bytearray(((Geometry) this.value).convertToWKB());
                                     case WKT:
                                     default:
                                         return ((Geometry) this.value).convertToWKT();
+                                }
                             } else if (this.value instanceof IProjection) {
                                 return getSRSId((IProjection) this.value);
+                            }
                             return this.value;
                         case Variable:
                         case Geometry:
                         default:
                             return this.value;
+                    }
                 } catch (Exception ex) {
                     throw new RuntimeException("Can't get value from parameter.", ex);
+                }
+            }
             @Override
             public ParameterType getType() {
                 return this.type;
+            }
             @Override
             public Value getSRS() {
                 return this.srs;
+            }
             @Override
             public String toString() {
                 switch (this.type) {
                     case Constant:
                     case Variable:
                     default:
                         return "?";
                     case Geometry:
                         switch (config.getGeometryTypeSupport()) {
                             case EWKB:
                                 return MessageFormat.format(
                                         config.getString(Config.ST_GeomFromEWKB),
                                         "?",
                                         String.valueOf(this.srs.toString())
                                 );
                             case WKB:
                                 return MessageFormat.format(
                                         config.getString(Config.ST_GeomFromWKB),
                                         "?",
                                         String.valueOf(this.srs.toString())
                                 );
                             case WKT:
                             default:
                                 return MessageFormat.format(
                                         config.getString(Config.ST_GeomFromText),
                                         "?",
                                         String.valueOf(this.srs.toString())
                                 );
+                        }
+                }
+            }
+        }
         public class ConstantBase extends AbstractValue implements Constant {
             protected Object value;
             public ConstantBase(Object value) {
                 this.value = value;
+            }
             @Override
             public Object getValue() {
                 return this.value;
+            }
             @Override
             public String toString() {
                 if (this.value instanceof String) {
                     return string((String) this.value);
+                }
                 if (this.value instanceof Boolean) {
                     if (((Boolean) this.value)) {
                         return config.getString(Config.constant_true);
                     } else {
                         return config.getString(Config.constant_false);
+                    }
+                }
                 return ObjectUtils.toString(this.value, "");
+            }
+        }
         public class CustomBase extends AbstractValue implements Custom {
             protected Object value;
             // Esto es para permitir declarar parametros y columnas en una seccion
             // custom.
             protected List<Value> values;
             public CustomBase(Object value) {
                 this.value = value;
+            }
             @Override
             public void accept(Visitor visitor, VisitorFilter filter) {
                 super.accept(visitor, filter);
                 if (this.values != null) {
                     for (Value value : values) {
                         value.accept(visitor, filter);
+                    }
+                }
+            }
             @Override
             public Object getValue() {
                 return this.value;
+            }
             @Override
             public Custom add(Variable variable) {
                 if (this.values == null) {
                     this.values = new ArrayList<>();
+                }
                 this.values.add(variable);
                 return this;
+            }
             @Override
             public Custom add(Parameter parameter) {
                 if (this.values == null) {
                     this.values = new ArrayList<>();
+                }
                 this.values.add(parameter);
                 return this;
+            }
             @Override
             public String toString() {
                 return ObjectUtils.toString(this.value, "");
+            }
+        }
         public class GeometryValueBase extends AbstractValue implements GeometryValue {
             protected Geometry geometry;
             protected IProjection projection;
             public GeometryValueBase(Geometry geometry, IProjection projection) {
                 this.geometry = geometry;
                 this.projection = projection;
+            }
             @Override
             public Geometry getGeometry() {
                 return this.geometry;
+            }
             @Override
             public IProjection getSRS() {
                 return this.projection;
+            }
             @Override
             public String toString() {
                 try {
                     switch (config.getGeometryTypeSupport()) {
                         case EWKB:
                             return MessageFormat.format(
                                     config.getString(Config.ST_GeomFromEWKB),
                                     bytearray(this.geometry.convertToEWKB()),
                                     String.valueOf(getSRSId(this.projection))
                             );
                         case WKB:
                             return MessageFormat.format(
                                     config.getString(Config.ST_GeomFromWKB),
                                     bytearray(this.geometry.convertToWKB()),
                                     String.valueOf(getSRSId(this.projection))
                             );
                         case WKT:
                         default:
                             return MessageFormat.format(
                                     config.getString(Config.ST_GeomFromText),
                                     string(this.geometry.convertToWKT()),
                                     String.valueOf(getSRSId(this.projection))
                             );
+                    }
                 } catch (Exception ex) {
                     throw new RuntimeException("Can't convert geometry to string.", ex);
+                }
+            }
+        }
         public class FunctionBase extends AbstractValue implements Function {
             protected String name;
             protected String format;
             protected List<Value> parameters;
             public FunctionBase(String name, String format) {
                 this.name = name;
                 this.format = format;
+            }
             public FunctionBase(String name) {
                 this(name,null);
+            }
             @Override
             public List<Value> parameters() {
                 if (this.parameters == null) {
                     this.parameters = new ArrayList<>();
+                }
                 return this.parameters;
+            }
             @Override
             public Function parameter(Value parameter) {
                 this.parameters().add(parameter);
                 return this;
+            }
             @Override
             public String getName() {
                 return this.name;
+            }
             @Override
             public void accept(Visitor visitor, VisitorFilter filter) {
                 super.accept(visitor, filter);
                 for (Value value : this.parameters) {
                     value.accept(visitor, filter);
+                }
+            }
             @Override
             public String toString() {
                 if( this.format==null ) {
                     StringBuilder builder = new StringBuilder();
                     builder.append(name);
                     builder.append("(");
                     if (this.parameters != null && !this.parameters.isEmpty()) {
                         boolean first = true;
                         for (Value value : this.parameters) {
                             if( first ) {
                                 first=false;
                                 builder.append(value.toString());
                             } else {
                                 builder.append(", ");
                                 builder.append(value.toString());
+                            }
+                        }
+                    }
                     builder.append(")");
                     return builder.toString();
+                }
                 if (this.parameters != null && !this.parameters.isEmpty()) {
                     List<String> values = new ArrayList<>();
                     for (Value value : this.parameters) {
                         values.add(value.toString());
+                    }
                     return MessageFormat.format(format, values.toArray());
                 } else {
                     return this.format;
+                }
+            }
+        }
         public class BinaryOperatorBase extends AbstractValue implements BinaryOperator {
             protected String name;
             protected String format;
             protected Value left;
             protected Value right;
             public BinaryOperatorBase(String name, String format) {
                 this.name = name;
                 this.format = format;
+            }
             @Override
             public String getName() {
                 return this.name;
+            }
             @Override
             public void accept(Visitor visitor, VisitorFilter filter) {
                 super.accept(visitor, filter);
                 this.left.accept(visitor, filter);
                 this.right.accept(visitor, filter);
+            }
             @Override
             public BinaryOperator setLeft(Value operand) {
                 this.left = operand;
                 return this;
+            }
             @Override
             public BinaryOperator setRight(Value operand) {
                 this.right = operand;
                 return this;
+            }
             @Override
             public Value getLeft() {
                 return this.left;
+            }
             @Override
             public Value getRight() {
                 return this.right;
+            }
             @Override
             public String toString() {
                 return MessageFormat.format(
                         format,
                         this.left.toString(),
                         this.right.toString()
                 );
+            }
+        }
         public class TableNameBuilderBase implements TableNameBuilder {
             public String tableName;
             public String schemaName;
             private String databaseName;
-...
             @Override
             public void accept(Visitor visitor, VisitorFilter filter) {
                 if( filter.accept(this) ) {
                 if (filter.accept(this)) {
                     visitor.visit(this);
+                }
+            }
-...
             @Override
             public TableNameBuilder schema(String name) {
                 if( supportSchemas() ) {
                 if (support_schemas()) {
                     this.schemaName = name;
+                }
                 return this;
-...
             public String getName() {
                 return this.tableName;
+            }
             @Override
             public boolean has_schema() {
                 if( !supportSchemas() ) {
                 if (!support_schemas()) {
                     return false;
+                }
                 return !StringUtils.isEmpty(this.schemaName);
-...
             public boolean has_database() {
                 return !StringUtils.isEmpty(this.databaseName);
+            }
             @Override
             public String toString() {
                 if( this.has_database()) {
                     if( this.has_schema()) {
                         return identifier(this.databaseName) + "." +
                                identifier(this.schemaName) + "." +
                                identifier(this.tableName);
                 return this.toString(formatter());
+            }
             @Override
             public String toString(Formatter<Value> formatter) {
                 if (formatter.canApply(this)) {
                     return formatter.format(this);
+                }
                 if (this.has_database()) {
                     if (this.has_schema()) {
                         return as_identifier(this.databaseName) + "."
                                 + as_identifier(this.schemaName) + "."
                                 + as_identifier(this.tableName);
+                    }
                 } else {
                     if( this.has_schema()) {
                         return identifier(this.schemaName) + "." +
                                identifier(this.tableName);
+                    }
                     if (this.has_schema()) {
                         return as_identifier(this.schemaName) + "."
                                 + as_identifier(this.tableName);
+                    }
+                }
                 return identifier(this.tableName);
                 return as_identifier(this.tableName);
+            }
+        }
         public class CountBuilderBase extends AbstractValue implements CountBuilder {
         public class CountBuilderBase
                 extends AbstractStatementPart
                 implements CountBuilder {
             protected Value value;
             protected boolean distinct;
             protected boolean all ;
             protected boolean all;
             public CountBuilderBase() {
                 this.value = null;
                 this.distinct = false;
                 this.all = false;
+            }
             @Override
             public CountBuilder all() {
                 this.all = true;
-...
             @Override
             public String toString() {
                 if( this.all ) {
                     return MessageFormat.format(
                         config.getString(SQLConfig.count),
                         "*"
                     );
                 return this.toString(formatter());
+            }
             @Override
             public String toString(Formatter formatter) {
                 if (formatter.canApply(this)) {
                     return formatter.format(this);
+                }
                 if( this.distinct ) {
                 if (this.all) {
                     return "COUNT(*)";
+                }
                 if (this.distinct) {
                     return MessageFormat.format(
                         config.getString(SQLConfig.count_distinct),
                         value.toString()
                             "COUNT(DISTINCT {0})",
                             value.toString(formatter)
                     );
+                }
                 return MessageFormat.format(
                     config.getString(SQLConfig.count),
                     value.toString()
                         "COUNT({0})",
                         value.toString(formatter)
                 );
+            }
+        }
         public class FromBuilderBase implements FromBuilder {
             protected TableNameBuilder tableName= null;
         public class FromBuilderBase
                 extends AbstractStatementPart
                 implements FromBuilder {
             protected TableNameBuilder tableName = null;
             private String subquery = null;
             private String passthrough = null;
             @Override
             public TableNameBuilder table() {
                 if( tableName == null ) {
                 if (tableName == null) {
                     this.tableName = createTableNameBuilder();
+                }
                 return this.tableName;
-...
             @Override
             public void accept(Visitor visitor, VisitorFilter filter) {
                 if( filter.accept(this) ) {
                 if (filter.accept(this)) {
                     visitor.visit(this);
+                }
                 if( this.tableName != null ) {
                 if (this.tableName != null) {
                     this.tableName.accept(visitor, filter);
+                }
+            }
-...
                 this.subquery = subquery;
                 return this;
+            }
             @Override
             public String toString() {
                 if( ! StringUtils.isEmpty(passthrough) ) {
                 return this.toString(formatter());
+            }
             @Override
             public String toString(Formatter<Value> formatter) {
                 if (formatter.canApply(this)) {
                     return formatter.format(this);
+                }
                 if (!StringUtils.isEmpty(passthrough)) {
                     return passthrough;
+                }
                 if( ! StringUtils.isEmpty(subquery) ) {
                 if (!StringUtils.isEmpty(subquery)) {
                     return "( " + this.subquery + ") as _subquery_alias_ ";
+                }
                 return this.tableName.toString();
                 return this.tableName.toString(formatter);
+            }
+        }
         public class SelectColumnBuilderBase implements SelectColumnBuilder {
         public class SelectColumnBuilderBase
                 extends AbstractStatementPart
                 implements SelectColumnBuilder {
             private Variable name = null;
             private String alias = null;
             private Value value = null;
             private boolean asGeometry = false;
             @Override
             public void accept(Visitor visitor, VisitorFilter filter) {
                 if( filter.accept(this) ) {
                 if (filter.accept(this)) {
                     visitor.visit(this);
+                }
                 if( this.name != null ) {
                 if (this.name != null) {
                     this.name.accept(visitor, filter);
+                }
                 if( this.value != null ) {
                 if (this.value != null) {
                     this.value.accept(visitor, filter);
+                }
+            }
             @Override
             public SelectColumnBuilder name(String name) {
                 String quote = config.getString(Config.quote_for_identifiers);
                 String quote = quote_for_identifiers();
                 if (name.startsWith(quote)) {
                     // Remove quotes
                     name = name.substring(1, name.length() - 1);
+                }
                 this.name = variable(name);
                 this.name = expression().variable(name);
                 this.value = null;
                 this.asGeometry = false;
                 return this;
-...
             @Override
             public SelectColumnBuilder all() {
                 this.name = null;
                 this.value = custom("*");
                 this.value = expression().custom("*");
                 this.asGeometry = false;
                 return this;
+            }
             @Override
             public SelectColumnBuilder as_geometry() {
                 this.asGeometry = true;
                 return this;
+            }
             @Override
             public SelectColumnBuilder value(Value value) {
                 this.value = value;
-...
             @Override
             public String getName() {
                 return this.name.getName();
                 return this.name.name();
+            }
             @Override
             public String getAlias() {
                 return this.alias;
+            }
             @Override
             public String getValue() {
                 return this.alias;
-...
             @Override
             public String toString() {
                 return this.toString(formatter());
+            }
             @Override
             public String toString(Formatter<Value> formatter) {
                 if (formatter.canApply(this)) {
                     return formatter.format(this);
+                }
                 StringBuilder builder = new StringBuilder();
                 if( this.asGeometry ) {
                     builder.append(getAsGeometry(this.name).toString());
                 if (this.asGeometry) {
                     builder.append(expression().ST_AsBinary(this.name).toString(formatter));
                 } else {
                     if( this.name != null ) {
                         builder.append(this.name.toString());
                     if (this.name != null) {
                         builder.append(this.name.toString(formatter));
                     } else {
                         builder.append(this.value.toString());
                         builder.append(this.value.toString(formatter));
+                    }
+                }
                 if( this.alias != null ) {
                 if (this.alias != null) {
                     builder.append(" AS ");
                     builder.append(identifier(this.alias));
                     builder.append(as_identifier(this.alias));
+                }
                 return builder.toString();
+            }
+        }
         public class OrderByBuilderBase implements OrderByBuilder {
         public class OrderByBuilderBase
                 extends AbstractStatementPart
                 implements OrderByBuilder {
             protected String value;
             protected String custom;
             protected boolean ascending;
             public OrderByBuilderBase() {
                 this.ascending = true;
+            }
             @Override
             public void accept(Visitor visitor, VisitorFilter filter) {
                 if( filter.accept(this) ) {
                 if (filter.accept(this)) {
                     visitor.visit(this);
+                }
+            }
-...
             @Override
             public String toString() {
                 if( !StringUtils.isEmpty(this.custom) ) {
                 return this.toString(formatter());
+            }
             @Override
             public String toString(Formatter<Value> formatter) {
                 if (formatter.canApply(this)) {
                     return formatter.format(this);
+                }
                 if (!StringUtils.isEmpty(this.custom)) {
                     return this.custom;
+                }
                 if( this.ascending ) {
                     return identifier(this.value) + " ASC";
                 if (this.ascending) {
                     return as_identifier(this.value) + " ASC";
+                }
                 return identifier(this.value) + " DESC";
                 return as_identifier(this.value) + " DESC";
+            }
+        }
         public class SelectBuilderBase implements SelectBuilder {
         public class SelectBuilderBase
                 extends AbstractStatement
                 implements SelectBuilder {
             protected FromBuilder from;
             protected ExpressionBuilder where;
             protected long limit = -1;
-...
             @Override
             public void accept(Visitor visitor, VisitorFilter filter) {
                 if( filter.accept(this) ) {
                 if (filter.accept(this)) {
                     visitor.visit(this);
+                }
                 for (SelectColumnBuilder column : columns) {
                     column.accept(visitor,filter);
                     column.accept(visitor, filter);
+                }
                 if( this.has_from() ) {
                     this.from.accept(visitor,filter);
                 if (this.has_from()) {
                     this.from.accept(visitor, filter);
+                }
                 if( this.has_where() ) {
                     this.where.accept(visitor,filter);
                 if (this.has_where()) {
                     this.where.accept(visitor, filter);
+                }
                 if( this.has_order_by() ) {
                 if (this.has_order_by()) {
                     for (OrderByBuilder order : order_by) {
                         order.accept(visitor,filter);
                         order.accept(visitor, filter);
+                    }
+                }
+            }
-...
                 this.distinct = true;
                 return this;
+            }
             @Override
             public SelectColumnBuilder column() {
                 SelectColumnBuilder builder = createSelectColumnBuilder();
-...
             @Override
             public boolean has_column(String name) {
                 for (SelectColumnBuilder column : columns) {
                     if( name.equals(column.getName()) ) {
                     if (name.equals(column.getName())) {
                         return true;
+                    }
+                }
-...
             public boolean has_from() {
                 return this.from != null;
+            }
             @Override
             public ExpressionBuilder where() {
                 if (this.where == null) {
-...
             @Override
             public boolean has_where() {
                 if( this.where == null ) {
                 if (this.where == null) {
                     return false;
+                }
                 return this.where.getValue() != null;
                 return this.where.value() != null;
+            }
             @Override
             public SelectBuilder limit(long limit) {
                 this.limit = limit;
-...
             @Override
             public SelectBuilder limit(Long limit) {
                 if( limit == null ) {
                 if (limit == null) {
                     this.limit = 0;
                 } else {
                     this.limit = limit;
-...
             @Override
             public OrderByBuilder order_by() {
                 if( this.order_by == null ) {
                 if (this.order_by == null) {
                     this.order_by = new ArrayList<>();
+                }
                 OrderByBuilder order = createOrderByBuilder();
-...
             @Override
             public boolean has_order_by() {
                 if( this.order_by == null ) {
                 if (this.order_by == null) {
                     return false;
+                }
                 return !this.order_by.isEmpty();
+            }
             protected boolean isValid(StringBuilder message) {
                 if( message == null ) {
                 if (message == null) {
                     message = new StringBuilder();
+                }
                 if( this.has_offset() && !this.has_order_by() ) {
                 if (this.has_offset() && !this.has_order_by()) {
                     // Algunos gestores de BBDD requieren que se especifique un
                     // orden para poder usar OFFSET. Como eso parece buena idea para
                     // asegurar que siempre tengamos los mismo resultados, lo exijimos
-...
+                }
                 return true;
+            }
             @Override
             public String toString() {
                 return this.toString(formatter());
+            }
             @Override
             public String toString(Formatter<Value> formatter) {
                 if (formatter.canApply(this)) {
                     return formatter.format(this);
+                }
                 StringBuilder builder = new StringBuilder();
                 if( !this.isValid(builder) ) {
                 if (!this.isValid(builder)) {
                     throw new IllegalStateException(builder.toString());
+                }
                 builder.append("SELECT ");
                 if( this.distinct ) {
                 if (this.distinct) {
                     builder.append("DISTINCT ");
+                }
                 boolean first = true;
-...
                     } else {
                         builder.append(", ");
+                    }
                     builder.append(column.toString());
                     builder.append(column.toString(formatter));
+                }
                 if ( this.has_from() ) {
                 if (this.has_from()) {
                     builder.append(" FROM ");
                     builder.append(this.from.toString());
                     builder.append(this.from.toString(formatter));
+                }
                 if ( this.has_where() ) {
                 if (this.has_where()) {
                     builder.append(" WHERE ");
                     builder.append(this.where.toString());
                     builder.append(this.where.toString(formatter));
+                }
                 if( this.has_order_by() ) {
                 if (this.has_order_by()) {
                     builder.append(" ORDER BY ");
                     first = true;
                     for (OrderByBuilder item : this.order_by) {
-...
                         } else {
                             builder.append(", ");
+                        }
                         builder.append(item.toString());
+                    }
                         builder.append(item.toString(formatter));
+                    }
+                }
                 if ( this.has_limit() ) {
                 if (this.has_limit()) {
                     builder.append(" LIMIT ");
                     builder.append(this.limit);
+                }
                 if ( this.has_offset() ) {
                 if (this.has_offset()) {
                     builder.append(" OFFSET ");
                     builder.append(this.offset);
+                }
-...
+            }
+        }
         public class DropTableBuilderBase implements DropTableBuilder {
         public class DropTableBuilderBase
                 extends AbstractStatement
                 implements DropTableBuilder {
             protected TableNameBuilder table;
             @Override
             public TableNameBuilder table() {
                 if( table == null ) {
                 if (table == null) {
                     table = createTableNameBuilder();
+                }
                 return table;
-...
             @Override
             public void accept(Visitor visitor, VisitorFilter filter) {
                 if( filter.accept(this) ) {
                 if (filter.accept(this)) {
                     visitor.visit(this);
+                }
                 this.table.accept(visitor,filter);
                 this.table.accept(visitor, filter);
+            }
             @Override
             public String toString() {
                 return this.toString(formatter());
+            }
             @Override
             public String toString(Formatter<Value> formatter) {
                 if (formatter.canApply(this)) {
                     return formatter.format(this);
+                }
                 StringBuilder builder = new StringBuilder();
                 boolean first = true;
                 for (String sql : toStrings()) {
                     if( StringUtils.isEmpty(sql) ) {
                 for (String sql : toStrings(formatter)) {
                     if (StringUtils.isEmpty(sql)) {
                         continue;
+                    }
                     if (first) {
-...
             @Override
             public List<String> toStrings() {
                 return this.toStrings(formatter());
+            }
             @Override
             public List<String> toStrings(Formatter formatter) {
                 List<String> sqls = new ArrayList<>();
                 sqls.add(
                         MessageFormat.format(
                                 config.getString(SQLConfig.DROP_TABLE_table),
                                 this.table.toString()
                                 STMT_DROP_TABLE_table,
                                 this.table.toString(formatter)
+                        )
                 );
                 String sql;
                 if( config.has_functionality(SQLConfig.DELETE_GEOMETRY_COLUMN_FROM_TABLE_schema_table) ) {
                 if (!StringUtils.isBlank(STMT_DELETE_GEOMETRY_COLUMN_FROM_TABLE_schema_table)) {
                     if (this.table.has_schema()) {
                         sql = MessageFormat.format(
                                 config.getString(SQLConfig.DELETE_GEOMETRY_COLUMN_FROM_TABLE_schema_table),
                                 string(this.table.getSchema()),
                                 string(this.table.getName())
                                 STMT_DELETE_GEOMETRY_COLUMN_FROM_TABLE_schema_table,
                                 as_string(this.table.getSchema()),
                                 as_string(this.table.getName())
                         );
                     } else {
                         sql = MessageFormat.format(
                                 config.getString(SQLConfig.DELETE_GEOMETRY_COLUMN_FROM_TABLE_table),
                                 identifier(this.table.getName())
                                 STMT_DELETE_GEOMETRY_COLUMN_FROM_TABLE_table,
                                 as_identifier(this.table.getName())
                         );
+                    }
                     if( !StringUtils.isEmpty(sql) ) {
                     if (!StringUtils.isEmpty(sql)) {
                         sqls.add(sql);
+                    }
+                }
-...
+            }
+        }
         public class GrantRoleBuilderBase implements GrantRoleBuilder {
         public class GrantRoleBuilderBase
                 extends AbstractStatementPart
                 implements GrantRoleBuilder {
             protected TableNameBuilder table;
             protected String role;
             protected Set<Privilege> privileges;
-...
                 privileges.add(privilege);
                 return this;
+            }
             @Override
             public GrantRoleBuilder select() {
                  privileges.add(Privilege.SELECT);
                 privileges.add(Privilege.SELECT);
                 return this;
+            }

... This diff was truncated because it exceeds the maximum size that can be displayed.

Also available in: Unified diff