Application: gvSIG desktop

package org.gvsig.fmap.dal.feature.spi;

import java.text.MessageFormat;

import java.util.ArrayList;

import java.util.Collections;

import java.util.HashMap;

import java.util.HashSet;

import java.util.List;

import java.util.Map;

import java.util.Objects;

import java.util.Set;

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 org.gvsig.expressionevaluator.ExpressionBuilder.AbstractValue;

import org.gvsig.expressionevaluator.ExpressionBuilder.ClassVisitorFilter;

import static org.gvsig.expressionevaluator.ExpressionBuilder.PARAMETER_TYPE_CONSTANT;

import static org.gvsig.expressionevaluator.ExpressionBuilder.PARAMETER_TYPE_VARIABLE;

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

import org.gvsig.expressionevaluator.GeometryExpressionBuilder;

import org.gvsig.expressionevaluator.GeometryExpressionBuilderHelper.GeometrySupportType;

import org.gvsig.expressionevaluator.GeometryExpressionEvaluatorLocator;

import org.gvsig.fmap.dal.DataStoreParameters;

import org.gvsig.fmap.dal.DataTypes;

import org.gvsig.fmap.dal.SQLBuilder;

import org.gvsig.fmap.dal.SQLBuilder.AlterTableBuilder;

import org.gvsig.fmap.dal.SQLBuilder.CreateTableBuilder;

import org.gvsig.fmap.dal.SQLBuilder.DeleteBuilder;

import org.gvsig.fmap.dal.SQLBuilder.DropTableBuilder;

import org.gvsig.fmap.dal.SQLBuilder.FromBuilder;

import org.gvsig.fmap.dal.SQLBuilder.GrantBuilder;

import org.gvsig.fmap.dal.SQLBuilder.InsertBuilder;

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

import org.gvsig.fmap.dal.SQLBuilder.SelectColumnBuilder;

import org.gvsig.fmap.dal.SQLBuilder.TableNameBuilder;

import org.gvsig.fmap.dal.SQLBuilder.UpdateBuilder;

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.geom.Geometry;

import org.gvsig.tools.dataTypes.DataType;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import static org.gvsig.expressionevaluator.ExpressionBuilder.BASE_FORMATTER;

@SuppressWarnings("UseSpecificCatch")

public class SQLBuilderBase implements SQLBuilder {

    protected static final Logger LOGGER = LoggerFactory.getLogger(SQLBuilderBase.class);

    protected SelectBuilder select;

    protected UpdateBuilder update;

    protected InsertBuilder insert;

    protected DeleteBuilder delete;

    protected AlterTableBuilder alter_table;

    protected CreateTableBuilder create_table;

    protected GrantBuilder grant;

    protected DropTableBuilder drop_table;

    protected UpdateTableStatisticsBuilder update_table_statistics;

    protected CreateIndexBuilder create_index;

    protected TableNameBuilder table_name;

    protected abstract class AbstractStatementPart extends AbstractValue {

    }

    protected abstract class AbstractStatement extends AbstractStatementPart {

    }

    protected class ColumnDescriptorBase implements ColumnDescriptor {

        private String name;

        private int type;

        private int size;

        private int precision;

        private int scale;

        private boolean isPk;

        private boolean _allowNulls;

        private boolean _isAutomatic;

        private Object defaultValue;

        private int geom_type;

        private int geom_subtype;

        private Object geom_srsdbcode;

        private boolean _isIndexed;

        private DataStoreParameters parameters = null;

        public ColumnDescriptorBase(String name, int type, Object defaultValue) {

            this.name = name;

            this.type = type;

            this.size = -1;

            this.precision = -1;

            this.scale = -1;

            this.isPk = false;

            this._allowNulls = true;

            this._isAutomatic = false;

            this.defaultValue = defaultValue;

            this.geom_type = Geometry.TYPES.GEOMETRY;

            this.geom_subtype = Geometry.SUBTYPES.GEOM2D;

            this.geom_srsdbcode = null;

            this._isIndexed = false;

        }

        public ColumnDescriptorBase(String name, int type, int size, int precision, int scale, boolean isPk, boolean isIndexed, boolean allowNulls, boolean isAutomatic, Object defaultValue) {

            this.name = name;

            this.type = type;

            this.size = size;

            this.precision = precision;

            this.scale = scale;

            this.isPk = isPk;

            this._allowNulls = allowNulls;

            this._isAutomatic = isAutomatic;

            this.defaultValue = defaultValue;

            this.geom_type = Geometry.TYPES.GEOMETRY;

            this.geom_subtype = Geometry.SUBTYPES.GEOM2D;

            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.size = 0;

            this.precision = 0;

            this.scale = 0;

            this.isPk = false;

            this._allowNulls = allowNulls;

            this._isAutomatic = false;

            this.defaultValue = null;

            this.geom_type = geom_type;

            this.geom_subtype = geom_subtype;

            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.size = 0;

            this.precision = 0;

            this.scale = 0;

            this.isPk = false;

            this._allowNulls = allowNulls;

            this._isAutomatic = false;

            this.defaultValue = null;

            this.geom_type = geom_type;

            this.geom_subtype = geom_subtype;

            this.geom_srsdbcode = srsdbcode;

            this._isIndexed = isIndexed;

        }

        private ColumnDescriptorBase(FeatureAttributeDescriptor fad) {

            this(fad.getName(), fad.getType(), fad.getDefaultValue());

            this.precision = fad.getPrecision();

            this.size = fad.getSize();

            this.scale = fad.getScale();

            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 int getType() {

            return this.type;

        }

        @Override

        public void setType(int type) {

            this.type = type;

        }

        @Override

        public int getPrecision() {

            return precision;

        }

        @Override

        public void setPrecision(int precision) {

            this.precision = precision;

        }

        @Override

        public int getScale() {

            return scale;

        }

        @Override

        public void setScale(int scale) {

            this.scale = scale;

        }

        @Override

        public int getSize() {

            return size;

        }

        @Override

        public void setSize(int size) {

            this.size = size;

        }

        @Override

        public boolean isPrimaryKey() {

            return isPk;

        }

        @Override

        public void setIsPrimaryKey(boolean isPk) {

            this.isPk = isPk;

        }

        @Override

        public boolean allowNulls() {

            return _allowNulls;

        }

        @Override

        public void setAllowNulls(boolean allowNulls) {

            this._allowNulls = allowNulls;

        }

        @Override

        public boolean isAutomatic() {

            return _isAutomatic;

        }

        @Override

        public boolean isIndexed() {

            return _isIndexed;

        }

        @Override

        public void setIsAutomatic(boolean isAutomatic) {

            this._isAutomatic = isAutomatic;

        }

        @Override

        public Object getDefaultValue() {

            return defaultValue;

        }

        @Override

        public void setDefaultValue(Object defaultValue) {

            this.defaultValue = defaultValue;

        }

        @Override

        public int getGeometryType() {

            return geom_type;

        }

        @Override

        public void setGeometryType(int geom_type) {

            this.geom_type = geom_type;

        }

        @Override

        public int getGeometrySubtype() {

            return geom_subtype;

        }

        @Override

        public void setGeometrySubtype(int geom_subtype) {

            this.geom_subtype = geom_subtype;

        }

        @Override

        public Object getGeometrySRSId() {

            return geom_srsdbcode;

        }

        @Override

        public void setGeometrySRSId(Object geom_srsid) {

            this.geom_srsdbcode = geom_srsid;

        }

        @Override

        public boolean isGeometry() {

            return this.type == DataTypes.GEOMETRY;

        }

        private void setStoreParameters(DataStoreParameters parameters) {

            this.parameters = parameters;

        }

        @Override

        public DataStoreParameters getStoreParameters() {

            return this.parameters;

        }

    }

    public class ColumnBase extends AbstractValue implements Column {

        private final String name;

        private TableNameBuilder table;

        public ColumnBase(TableNameBuilder table, String name) {

            this.name = name;

            this.table = table;

        }

        @Override

        public String name() {

            return this.name;

        }

        @Override

        public TableNameBuilder table() {

            return this.table;

        }

        @Override

        public TableNameBuilder table(TableNameBuilder table) {

            this.table = table;

            return this.table;

        }

        @Override

        public String toString() {

            return this.toString(BASE_FORMATTER);

        }

        @Override

        public String toString(Formatter<Value> formatter) {

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

                return formatter.format(this);

            }

            if( this.table==null ) {

                return as_identifier(this.name);

            }

            return this.table.toString(formatter) + "." + as_identifier(this.name);

        }

        @Override

        public int compareTo(Variable o) {

            return this.name.compareTo(o.name());

        }

        @Override

        public boolean equals(Object obj) {

            if (!(obj instanceof Variable)) {

                return false;

            }

            return StringUtils.equals(this.toString(), ((Variable) obj).toString());

        }

        @Override

        public int hashCode() {

            int hash = 7;

            hash = 37 * hash + Objects.hashCode(this.toString());

            return hash;

        }

    }

    public class TableNameBuilderBase

            extends AbstractStatementPart

            implements TableNameBuilder {

        public String tableName;

        public String schemaName;

        private String databaseName;

        public TableNameBuilderBase() {

        }

        @Override

        public void accept(Visitor visitor, VisitorFilter filter) {

            if (filter.accept(this)) {

                visitor.visit(this);

            }

        }

        @Override

        public TableNameBuilder database(String name) {

            this.databaseName = name;

            return this;

        }

        @Override

        public TableNameBuilder schema(String name) {

            if (support_schemas()) {

                this.schemaName = name;

            }

            return this;

        }

        @Override

        public TableNameBuilder name(String name) {

            this.tableName = name;

            return this;

        }

        @Override

        public String getDatabase() {

            return this.databaseName;

        }

        @Override

        public String getSchema() {

            return this.schemaName;

        }

        @Override

        public String getName() {

            return this.tableName;

        }

        @Override

        public boolean has_schema() {

            if (!support_schemas()) {

                return false;

            }

            return !StringUtils.isEmpty(this.schemaName);

        }

        @Override

        public boolean has_database() {

            return !StringUtils.isEmpty(this.databaseName);

        }

        @Override

        public String toString() {

            return this.toString(formatter());

        }

        @Override

        public String toString(Formatter<Value> formatter) {

            if (formatter!=null && 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 as_identifier(this.schemaName) + "."

                            + as_identifier(this.tableName);

                }

            }

            return as_identifier(this.tableName);

        }

        @Override

        public boolean equals(Object obj) {

            if( obj==null || !(obj instanceof TableNameBuilder) ) {

                return false;

            }

            TableNameBuilder other = (TableNameBuilder) obj;

            if (this.has_database()) {

                if (this.has_schema()) {

                    return this.databaseName.equals(other.getDatabase()) &&

                           this.schemaName.equals(other.getSchema()) &&

                           this.tableName.equals(other.getName());

                }

            } else {

                if (this.has_schema()) {

                    return this.schemaName.equals(other.getSchema()) &&

                           this.tableName.equals(other.getName());

                }

            }

            return this.tableName.equals(other.getName());

        }

        @Override

        public int hashCode() {

            int hash = 7;

            hash = 37 * hash + Objects.hashCode(this.toString());

            return hash;

        }

    }

    public class CountBuilderBase

            extends AbstractStatementPart

            implements CountBuilder {

        protected Value value;

        protected boolean distinct;

        protected boolean all;

        public CountBuilderBase() {

            this.value = null;

            this.distinct = false;

            this.all = false;

        }

        @Override

        public CountBuilder all() {

            this.all = true;

            return this;

        }

        @Override

        public CountBuilder column(Value value) {

            this.value = value;

            return this;

        }

        @Override

        public CountBuilder distinct() {

            this.distinct = true;

            return this;

        }

        @Override

        public String toString() {

            return this.toString(formatter());

        }

        @Override

        public String toString(Formatter formatter) {

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

                return formatter.format(this);

            }

            if (this.all) {

                return "COUNT(*)";

            }

            if (this.distinct) {

                return MessageFormat.format(

                        "COUNT(DISTINCT {0})",

                        value.toString(formatter)

                );

            }

            return MessageFormat.format(

                    "COUNT({0})",

                    value.toString(formatter)

            );

        }

    }

    protected class JoinBase 

            extends AbstractStatementPart

            implements StatementPart 

        {

        protected String type;

        protected TableNameBuilder table;

        protected Value expression;

        public JoinBase(String type, TableNameBuilder table, Value expression) {

            this.type = type;

            this.table = table;

            this.expression = expression;

        }

        @Override

        public String toString() {

            return this.toString(formatter());

        }

        @Override

        public String toString(Formatter<Value> formatter) {

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

                return formatter.format(this);

            }

            StringBuilder builder = new StringBuilder();

            // INNER JOIN Customers ON Orders.CustomerID = Customers.CustomerID

            builder.append(this.type.toUpperCase());

            builder.append(" JOIN ");

            builder.append(this.table.toString(formatter));

            builder.append(" ON ");

            builder.append(this.expression.toString(formatter));

            return builder.toString();

        }

    }

    public class FromBuilderBase

            extends AbstractStatementPart

            implements FromBuilder {

        protected TableNameBuilder tableName;

        private String subquery;

        private String passthrough;

        private List<JoinBase> joins;

        public FromBuilderBase() {

            this.tableName = null;

            this.subquery = null;

            this.passthrough = null;

            this.joins = null;

        }

        @Override

        public FromBuilder left_join(TableNameBuilder table, Value expression) {

            JoinBase join = createJoin("LEFT", table, expression);

            if( this.joins==null ) {

                this.joins = new ArrayList<>();

            }

            this.joins.add(join);

            return this;

        }

        @Override

        public TableNameBuilder table() {

            if (tableName == null) {

                this.tableName = createTableNameBuilder();

            }

            return this.tableName;

        }

        @Override

        public void accept(Visitor visitor, VisitorFilter filter) {

            if (filter.accept(this)) {

                visitor.visit(this);

            }

            if (this.tableName != null) {

                this.tableName.accept(visitor, filter);

            }

        }

        @Override

        public FromBuilder custom(String passthrough) {

            this.passthrough = passthrough;

            return this;

        }

        @Override

        public FromBuilder subquery(String subquery) {

            this.subquery = subquery;

            return this;

        }

        @Override

        public String toString() {

            return this.toString(formatter());

        }

        @Override

        public String toString(Formatter<Value> formatter) {

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

                return formatter.format(this);

            }

            if (!StringUtils.isEmpty(passthrough)) {

                return passthrough;

            }

            if (!StringUtils.isEmpty(subquery)) {

                return "( " + this.subquery + ") as _subquery_alias_ ";

            }

            if( this.joins==null || this.joins.isEmpty() ) {

                return this.tableName.toString(formatter);

            }

            StringBuilder builder = new StringBuilder();

            builder.append(this.tableName.toString(formatter));

            for (JoinBase join : this.joins) {

                builder.append(" ");

                builder.append(join.toString(formatter));

            }

            return builder.toString();

        }

    }

    public class SelectColumnBuilderBase

            extends AbstractStatementPart

            implements SelectColumnBuilder {

        private Variable name = null;

        private String alias = null;

        private Value value = null;

        private boolean asGeometry = false;

        private TableNameBuilder table;

        @Override

        public void accept(Visitor visitor, VisitorFilter filter) {

            if (filter.accept(this)) {

                visitor.visit(this);

            }

            if (this.name != null) {

                this.name.accept(visitor, filter);

            }

            if (this.value != null) {

                this.value.accept(visitor, filter);

            }

        }

        @Override

        public void replace(Value target, Value replacement) {

            if (this.name!=null ) {

                if( this.name == target) {

                    this.name = (Variable) replacement;

                }

            }

            if( this.value!=null ) {

                if (this.value == target) {

                    this.value = replacement;

                } else {

                    this.value.replace(target, replacement);

                }

            }

        }

        @Override

        public SelectColumnBuilder name(String name) {

            return this.name(null, name);

        }

        @Override

        public SelectColumnBuilder name(TableNameBuilder table, String name) {

            String quote = quote_for_identifiers();

            if (name.startsWith(quote)) {

                // Remove quotes

                name = name.substring(1, name.length() - 1);

            }

            this.name = expression().variable(name);

            this.table = table;

            this.value = null;

            this.asGeometry = false;

            return this;

        }

        @Override

        public SelectColumnBuilder all() {

            this.name = null;

            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;

            this.name = null;

            return this;

        }

        @Override

        public SelectColumnBuilder as(String alias) {

            this.alias = alias;

            return this;

        }

        @Override

        public String 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!=null && formatter.canApply(this)) {

                return formatter.format(this);

            }

            StringBuilder builder = new StringBuilder();

            if (this.asGeometry) {

                builder.append(expression().ST_AsBinary(this.name).toString(formatter));

            } else {

                if (this.name != null) {

                    if( this.table==null ) {

                        builder.append(this.name.toString(formatter));

                    } else {

                        builder.append(this.table.toString(formatter));

                        builder.append(".");

                        builder.append(this.name.toString(formatter));

                    }

                } else {

                    builder.append(this.value.toString(formatter));

                }

            }

            if (this.alias != null) {

                builder.append(" AS ");

                builder.append(as_identifier(this.alias));

            }

            return builder.toString();

        }

    }

    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)) {

                visitor.visit(this);

            }

        }

        @Override

        public OrderByBuilder column(String name) {

            this.value = name;

            return this;

        }

        @Override

        public OrderByBuilder custom(String order) {

            this.custom = order;

            return this;

        }

        @Override

        public OrderByBuilder ascending() {

            this.ascending = true;

            return this;

        }

        @Override

        public OrderByBuilder ascending(boolean asc) {

            this.ascending = asc;

            return this;

        }

        @Override

        public OrderByBuilder descending() {

            this.ascending = false;

            return this;

        }

        @Override

        public String toString() {

            return this.toString(formatter());

        }

        @Override

        public String toString(Formatter<Value> formatter) {

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

                return formatter.format(this);

            }

            if (!StringUtils.isEmpty(this.custom)) {

                return this.custom;

            }

            if (this.ascending) {

                return as_identifier(this.value) + " ASC";

            }

            return as_identifier(this.value) + " DESC";

        }

    }

    public class SelectBuilderBase

            extends AbstractStatement

            implements SelectBuilder {

        protected FromBuilder from;

        protected GeometryExpressionBuilder where;

        protected long limit = -1;

        protected long offset = -1;

        protected List<SelectColumnBuilder> columns;

        protected List<OrderByBuilder> order_by;

        protected boolean distinct;

        protected List<Variable> groupColumn;

        protected boolean check_order_and_offset = true;

        public SelectBuilderBase() {

            this.columns = new ArrayList<>();

            this.distinct = false;

        }

        @Override

        public SelectBuilder group_by(Variable... columns) {

            if( this.groupColumn==null ) {

                this.groupColumn = new ArrayList<>();

            }

            for (Variable column : columns) {

                this.groupColumn.add(column);

            }

            return this;

        }

        @Override

        public void accept(Visitor visitor, VisitorFilter filter) {

            if (filter.accept(this)) {

                visitor.visit(this);

            }

            for (SelectColumnBuilder column : columns) {

                column.accept(visitor, filter);

            }

            if (this.has_from()) {

                this.from.accept(visitor, filter);

            }

            if (this.has_where()) {

                this.where.accept(visitor, filter);

            }

            if (this.has_order_by()) {

                for (OrderByBuilder order : order_by) {

                    order.accept(visitor, filter);

                }

            }

        }

        @Override

        public void replace(Value target, Value replacement) {

            if( this.columns!=null ) {

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

                    SelectColumnBuilder column = columns.get(i);

                    if( column == target ) {

                        columns.set(i, (SelectColumnBuilder) replacement);

                    } else {

                        column.replace(target, replacement);

                    }

                }

            }

            if (this.has_from()) {

                if( this.from == target ) {

                    this.from = (FromBuilder) replacement;

                } else {

                    this.from.replace(target, replacement);

                }

            }

            if (this.has_where()) {

                if( this.where == target ) {

                    this.where = (GeometryExpressionBuilder) replacement;

                } else if( this.where.value() == target ) {

                    this.where.value(replacement);

                } else {

                    this.where.value().replace(target, replacement);

                }

            }

            if (this.has_order_by()) {

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

                    OrderByBuilder order = order_by.get(i);

                    if( order == target ) {

                        order_by.set(i, (OrderByBuilder) replacement);

                    } else {

                        order.replace(target, replacement);

                    }

                }

            }

        }

        @Override

        public SelectBuilder distinct() {

            this.distinct = true;

            return this;

        }

        @Override

        public SelectColumnBuilder column() {

            SelectColumnBuilder builder = createSelectColumnBuilder();

            this.columns.add(builder);

            return builder;

        }

        @Override

        public SelectBuilder remove_all_columns() {

            this.columns = new ArrayList<>();

            return this;

        }

        @Override

        public boolean has_column(String name) {

            for (SelectColumnBuilder column : columns) {

                if (name.equals(column.getName())) {

                    return true;

                }

            }

            return false;

        }

        @Override

        public FromBuilder from() {

            if (this.from == null) {

                this.from = createFromBuilder();

            }

            return this.from;

        }

        @Override

        public boolean has_from() {

            return this.from != null;

        }

        @Override

        public GeometryExpressionBuilder where() {

            if (this.where == null) {

                this.where = createExpressionBuilder();

            }

            return this.where;

        }

        @Override

        public boolean has_where() {

            if (this.where == null) {

                return false;

            }

            return this.where.value() != null;

        }

        @Override

        public SelectBuilder limit(long limit) {

            this.limit = limit;

            return this;

        }

        @Override

        public SelectBuilder limit(Long limit) {

            if (limit == null) {

                this.limit = 0;

            } else {

                this.limit = limit;

            }

            return this;

        }

        @Override

        public boolean has_limit() {

            return this.limit > 0;

        }

        @Override

        public SelectBuilder offset(long offset) {

            this.offset = offset;

            return this;

        }

        @Override

        public boolean has_offset() {

            return this.offset > 0;

        }

        @Override

        public OrderByBuilder order_by() {

            if (this.order_by == null) {

                this.order_by = new ArrayList<>();

            }

            OrderByBuilder order = createOrderByBuilder();

            this.order_by.add(order);

            return order;

        }

        @Override

        public boolean has_order_by() {

            if (this.order_by == null) {

                return false;

            }

            return !this.order_by.isEmpty();

        }

        @Override

        public boolean has_group_by() {

            if (this.groupColumn == null) {

                return false;

            }

            return !this.groupColumn.isEmpty();

        }

        @Override

        public void disable_check_order_and_offset() {

          this.check_order_and_offset = false;

        }

        protected boolean isValid(StringBuilder message) {

            if (message == null) {

                message = new StringBuilder();

            }

            if( this.check_order_and_offset ) {

              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

                  // siempre.

                  message.append("Can't use OFFSET without an ORDER BY.");

                  return false;

              }

            }

            return true;

        }

        @Override

        public String toString() {

            return this.toString(formatter());

        }

        @Override

        public String toString(Formatter<Value> formatter) {

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

                return formatter.format(this);

            }

            StringBuilder builder = new StringBuilder();

            if (!this.isValid(builder)) {

                throw new IllegalStateException(builder.toString());

            }

            builder.append("SELECT ");

            if (this.distinct) {

                builder.append("DISTINCT ");

            }

            boolean first = true;

            for (SelectColumnBuilder column : columns) {

                if (first) {

                    first = false;

                } else {

                    builder.append(", ");

                }

                builder.append(column.toString(formatter));

            }

            if (this.has_from()) {

                builder.append(" FROM ");

                builder.append(this.from.toString(formatter));

            }

            if (this.has_where()) {

                builder.append(" WHERE ");

                builder.append(this.where.toString(formatter));

            }

            if( this.has_group_by() ) {

                builder.append(" GROUP BY ");

                builder.append(this.groupColumn.get(0).toString(formatter));

                for (int i = 1; i < groupColumn.size(); i++) {

                    builder.append(", ");

                    builder.append(this.groupColumn.get(i).toString(formatter));

                }

            }

            if (this.has_order_by()) {

                builder.append(" ORDER BY ");

                first = true;

                for (OrderByBuilder item : this.order_by) {

                    if (first) {

                        first = false;

                    } else {

                        builder.append(", ");

                    }

                    builder.append(item.toString(formatter));

                }

            }

            if (this.has_limit()) {

                builder.append(" LIMIT ");

                builder.append(this.limit);

            }

            if (this.has_offset()) {

                builder.append(" OFFSET ");

                builder.append(this.offset);

            }

            return builder.toString();

        }

    }

    public class DropTableBuilderBase

            extends AbstractStatement

            implements DropTableBuilder {

        protected TableNameBuilder table;

        @Override

        public TableNameBuilder table() {

            if (table == null) {

                table = createTableNameBuilder();

            }

            return table;

        }

        @Override

        public void accept(Visitor visitor, VisitorFilter filter) {

            if (filter.accept(this)) {

                visitor.visit(this);

            }

            this.table.accept(visitor, filter);

        }

        @Override

        public String toString() {

            return this.toString(formatter());

        }

        @Override

        public String toString(Formatter<Value> formatter) {

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

                return formatter.format(this);

            }

            StringBuilder builder = new StringBuilder();

            boolean first = true;

            for (String sql : toStrings(formatter)) {

                if (StringUtils.isEmpty(sql)) {

                    continue;

                }

                if (first) {

                    first = false;

                } else {

                    builder.append("; ");

                }

                builder.append(sql);

            }

            return builder.toString();

        }

        @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(

                            STMT_DROP_TABLE_table,

                            this.table.toString(formatter)

                    )

            );

            String sql;

            if (!StringUtils.isBlank(STMT_DELETE_GEOMETRY_COLUMN_FROM_TABLE_schema_table)) {

                if (this.table.has_schema()) {

                    sql = MessageFormat.format(

                            STMT_DELETE_GEOMETRY_COLUMN_FROM_TABLE_schema_table,

                            as_string(this.table.getSchema()),

                            as_string(this.table.getName())

                    );

                } else {

                    sql = MessageFormat.format(

                            STMT_DELETE_GEOMETRY_COLUMN_FROM_TABLE_table,

                            as_identifier(this.table.getName())

                    );

                }

                if (!StringUtils.isEmpty(sql)) {

                    sqls.add(sql);

                }

            }

            return sqls;

        }

    }

    public class GrantRoleBuilderBase

            extends AbstractStatementPart

            implements GrantRoleBuilder {

        protected TableNameBuilder table;