Application: gvSIG desktop

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

import java.text.MessageFormat;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.HashSet;

import java.util.List;

import java.util.Map;

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.fmap.dal.DataTypes;

import org.gvsig.fmap.dal.ExpressionBuilder;

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

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

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

import org.gvsig.fmap.dal.feature.spi.ExpressionBuilderBase.AbstractValue;

import org.gvsig.fmap.geom.Geometry;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class SQLBuilderBase extends ExpressionBuilderBase 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 List<Parameter> parameters;

    protected class ColumnDescriptorBuilderBase implements ColumnDescriptorBuilder {

        private String name;

        private int type;

        private int type_p;

        private int type_s;

        private boolean isPk;

        private boolean _allowNulls;

        private boolean _isAutomatic;

        private Object defaultValue;

        private int geom_type;

        private int geom_subtype;

        private int geom_srsid;

        private boolean _isIndexed;

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

            this.name = name;

            this.type = type;

            this.type_p = -1;

            this.type_s = -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_srsid = -1;

            this._isIndexed = false;

        }

        public ColumnDescriptorBuilderBase(String name, int type, int type_p, int type_s, boolean isPk, boolean isIndexed, boolean allowNulls, boolean isAutomatic, Object defaultValue) {

            this.name = name;

            this.type = type;

            this.type_p = type_p;

            this.type_s = type_s;

            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_srsid = -1;

            this._isIndexed = isIndexed;

        }

        public ColumnDescriptorBuilderBase(String name, int geom_type, int geom_subtype, IProjection proj, boolean isIndexed, boolean allowNulls) {

            this.name = name;

            this.type = DataTypes.GEOMETRY;

            this.type_p = 0;

            this.type_s = 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_srsid = getSRSId(proj);

            this._isIndexed = isIndexed;

        }

        @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 type_p;

        }

        @Override

        public void setPrecision(int precision) {

            this.type_p = precision;

        }

        @Override

        public int getSize() {

            return type_s;

        }

        @Override

        public void setSize(int size) {

            this.type_s = 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 int getGeometrySRSId() {

            return geom_srsid;

        }

        @Override

        public void setGeometrySRSId(int geom_srsid) {

            this.geom_srsid = geom_srsid;

        }        

        @Override

        public boolean isGeometry() {

            return this.type == DataTypes.GEOMETRY;

        }

    }

    public class TableNameBuilderBase 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( supportSchemas() ) {

                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( !supportSchemas() ) {

                return false;

            }

            return !StringUtils.isEmpty(this.schemaName);

        }

        @Override

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

                }

            } else {

                if( this.has_schema()) {

                    return identifier(this.schemaName) + "." + 

                           identifier(this.tableName);

                }                

            }

            return identifier(this.tableName);

        }

    }

    public class CountBuilderBase extends AbstractValue 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() {

            if( this.all ) {

                return MessageFormat.format(

                    config.getString(SQLConfig.count),

                    "*"

                );

            }

            if( this.distinct ) {

                return MessageFormat.format(

                    config.getString(SQLConfig.count_distinct),

                    value.toString()

                );

            }

            return MessageFormat.format(

                config.getString(SQLConfig.count),

                value.toString()

            );

        }

    }

    public class FromBuilderBase implements FromBuilder {

        protected TableNameBuilder tableName= null;

        private String subquery = null;

        private String passthrough = null;

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

            if( ! StringUtils.isEmpty(passthrough) ) {

                return passthrough;

            }

            if( ! StringUtils.isEmpty(subquery) ) {

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

            }

            return this.tableName.toString();

        }

    }

    public class SelectColumnBuilderBase 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) ) {

                visitor.visit(this);

            }

            if( this.name != null ) {

                this.name.accept(visitor, filter);

            }

            if( this.value != null ) {

                this.value.accept(visitor, filter);

            }

        }

        @Override

        public SelectColumnBuilder name(String name) {

            String quote = config.getString(Config.quote_for_identifiers);

            if (name.startsWith(quote)) {

                // Remove quotes

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

            }

            this.name = variable(name);

            this.value = null;

            this.asGeometry = false;

            return this;

        }

        @Override

        public SelectColumnBuilder all() {

            this.name = null;

            this.value = 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.getName();

        }

        @Override

        public String getAlias() {

            return this.alias;

        }

        @Override

        public String getValue() {

            return this.alias;

        }

        @Override

        public String toString() {

            StringBuilder builder = new StringBuilder();

            if( this.asGeometry ) {

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

            } else {

                if( this.name != null ) {

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

                } else {

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

                }

            }

            if( this.alias != null ) {

                builder.append(" AS ");

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

            }

            return builder.toString();

        }

    }

    public class OrderByBuilderBase 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() {

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

                return this.custom;

            }

            if( this.ascending ) {

                return this.value + " ASC";

            }

            return this.value + " DESC";

        }

    }

    public class SelectBuilderBase implements SelectBuilder {

        protected FromBuilder from;

        protected ExpressionBuilder where;

        protected long limit = -1;

        protected long offset = -1;

        protected List<SelectColumnBuilder> columns;

        protected List<OrderByBuilder> order_by;

        protected boolean distinct;

        public SelectBuilderBase() {

            this.columns = new ArrayList<>();

            this.distinct = false;

        }

        @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 SelectBuilder distinct() {

            this.distinct = true;

            return this;

        }

        @Override

        public SelectColumnBuilder column() {

            SelectColumnBuilder builder = createSelectColumnBuilder();

            this.columns.add(builder);

            return builder;

        }

        @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 ExpressionBuilder 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.getValue() != null;

        }

        @Override

        public SelectBuilder limit(long limit) {

            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();

        }

        protected boolean isValid(StringBuilder message) {

            if( message == null ) {

                message = new StringBuilder();

            }

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

            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());

            }

            if ( this.has_from() ) {

                builder.append(" FROM ");

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

            }

            if ( this.has_where() ) {

                builder.append(" WHERE ");

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

            }

            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());                    

                }   

            }

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

            StringBuilder builder = new StringBuilder();

            boolean first = true;

            for (String sql : toStrings()) {

                if( StringUtils.isEmpty(sql) ) {

                    continue;

                }

                if (first) {

                    first = false;

                } else {

                    builder.append("; ");

                }

                builder.append(sql);

            }

            return builder.toString();

        }

        @Override

        public List<String> toStrings() {

            List<String> sqls = new ArrayList<>();

            sqls.add(

                    MessageFormat.format(

                            config.getString(SQLConfig.DROP_TABLE_table),

                            this.table.toString()

                    )

            );

            String sql;

            if( config.has_functionality(SQLConfig.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())

                    );

                } else {

                    sql = MessageFormat.format(

                            config.getString(SQLConfig.DELETE_GEOMETRY_COLUMN_FROM_TABLE_table),

                            identifier(this.table.getName())

                    );

                }

                if( !StringUtils.isEmpty(sql) ) {

                    sqls.add(sql);

                }

            }

            return sqls;

        }

    }

    public class GrantRoleBuilderBase implements GrantRoleBuilder {

        protected TableNameBuilder table;

        protected String role;

        protected Set<Privilege> privileges;

        public GrantRoleBuilderBase(TableNameBuilder table, String role) {

            this.table = table;

            this.role = role;

            this.privileges = new HashSet<>();

        }

        @Override

        public GrantRoleBuilder privilege(Privilege privilege) {

            privileges.add(privilege);

            return this;

        }

        @Override

        public GrantRoleBuilder select() {

             privileges.add(Privilege.SELECT);

            return this;

        }

        @Override

        public GrantRoleBuilder update() {

             privileges.add(Privilege.UPDATE);

            return this;

        }

        @Override

        public GrantRoleBuilder insert() {

            privileges.add(Privilege.INSERT);

            return this;

        }

        @Override

        public GrantRoleBuilder delete() {

            privileges.add(Privilege.DELETE);

            return this;

        }

        @Override

        public GrantRoleBuilder truncate() {

            privileges.add(Privilege.TRUNCATE);

            return this;

        }

        @Override

        public GrantRoleBuilder reference() {

            privileges.add(Privilege.REFERENCE);

            return this;

        }

        @Override

        public GrantRoleBuilder trigger() {

            privileges.add(Privilege.TRIGGER);

            return this;

        }

        @Override

        public GrantRoleBuilder all() {

            privileges.add(Privilege.ALL);

            return this;

        }

        protected String getPrivilegeName(Privilege privilege) {

            switch(privilege) {

                case DELETE:

                    return "DELETE";

                case INSERT:

                    return "INSERT";

                case REFERENCE:

                    return "REFERENCE";

                case SELECT:

                    return "SELECT";

                case TRIGGER:

                    return "TRIGGER";

                case TRUNCATE:

                    return "TRUNCATE";

                case UPDATE:

                    return "UPDATE";

                case ALL:

                default:

                    return "ALL";

            }

        }

        @Override

        public String toString() {

            StringBuilder builder = new StringBuilder();

            boolean first = true;

            for (Privilege privilege : privileges) {

                if (first) {

                    first = false;

                } else {

                    builder.append(", ");

                }

                builder.append( this.getPrivilegeName(privilege));

            }

            String sql = MessageFormat.format(

                    config.getString(SQLConfig.GRANT_privileges_ON_table_TO_role),

                    builder.toString(),

                    table.toString(),

                    role

            );

            return sql;

        }

    }

    public class GrantBuilderBase implements GrantBuilder {

        protected TableNameBuilder table;

        protected Map<String, GrantRoleBuilder> roles;

        public GrantBuilderBase() {

            this.roles = new HashMap<>();

        }

        @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);

            }

            if( this.table!= null ) {

                this.table.accept(visitor,filter);

            }

        }

        @Override

        public GrantRoleBuilder role(String role) {

            GrantRoleBuilder roleBuilder = this.roles.get(role);

            if( roleBuilder == null ) {

                roleBuilder = createGrantRoleBuilder(this.table(), role);

                this.roles.put(role, roleBuilder);

            }

            return roleBuilder;

        }

        @Override

        public String toString() {

            StringBuilder builder = new StringBuilder();

            boolean first = true;

            for (String sql : toStrings()) {

                if( StringUtils.isEmpty(sql) ) {

                    continue;

                }

                if (first) {

                    first = false;

                } else {

                    builder.append("; ");

                }

                builder.append(sql);

            }

            return builder.toString();

        }

        @Override

        public List<String> toStrings() {

            List<String> sqls = new ArrayList<>();

            for (GrantRoleBuilder role : roles.values()) {

                sqls.add(role.toString());

            }

            return sqls;

        }

    }

    public class UpdateColumnBuilderBase extends InsertColumnBuilderBase implements UpdateColumnBuilder {

        public UpdateColumnBuilderBase() {

            super();

        }

        @Override

        public UpdateColumnBuilder name(String name) {

            return (UpdateColumnBuilder) super.name(name);

        }

        @Override

        public UpdateColumnBuilder with_value(Value value) {

            return (UpdateColumnBuilder) super.with_value(value);

        }

    }

    public class UpdateBuilderBase implements UpdateBuilder {

        protected ExpressionBuilder where;

        protected List<UpdateColumnBuilder> columns;

        protected TableNameBuilder table;

        public UpdateBuilderBase() {

            this.columns = new ArrayList<>();

        }

        @Override

        public void accept(Visitor visitor, VisitorFilter filter) {

            if( filter.accept(this) ) {

                visitor.visit(this);

            }

            if( this.table != null ) {

                this.table.accept(visitor, filter);

            }

            for (UpdateColumnBuilder column : columns) {

                column.accept(visitor, filter);

            }

            if( this.has_where() ) {

                this.where.accept(visitor, filter);

            }

        }

        @Override

        public ExpressionBuilder where() {

            if (this.where == null) {

                this.where = createExpressionBuilder();

            }

            return this.where;

        }

        @Override

        public TableNameBuilder table() {

            if( table == null ) {

                table = createTableNameBuilder();

            }

            return table;

        }

        @Override

        public UpdateColumnBuilder column() {

            UpdateColumnBuilder column = createUpdateColumnBuilder();

            this.columns.add(column);

            return column;

        }

        @Override

        public boolean has_where() {

            return this.where != null;

        }

        @Override

        public String toString() {

            /*

             * UPDATE [ ONLY ] table [ [ AS ] alias ] SET { column = { expression |

             * DEFAULT } | ( column [, ...] ) = ( { expression | DEFAULT } [, ...] )

             * } [, ...] [ FROM fromlist ] [ WHERE condition ] [ RETURNING * |

             * output_expression [ AS output_name ] [, ...] ]

             */

            StringBuilder columnsAndValues = new StringBuilder();

            boolean first = true;

            for (UpdateColumnBuilder column : columns) {

                if (first) {

                    first = false;

                } else {

                    columnsAndValues.append(", ");

                }

                columnsAndValues.append(identifier(column.getName()));

                columnsAndValues.append(" = ");

                columnsAndValues.append(column.getValue().toString());

            }

            String sql;

            if ( this.has_where() ) {

                sql = MessageFormat.format(

                        config.getString(SQLConfig.UPDATE_table_SET_columnsAndValues_WHERE_expresion),

                        this.table.toString(),

                        columnsAndValues.toString(),

                        this.where.toString()

                );

            } else {

                sql = MessageFormat.format(

                        config.getString(SQLConfig.UPDATE_table_SET_columnsAndValues),

                        this.table.toString(),

                        columnsAndValues.toString()

                );

            }

            return sql;

        }

    }

    public class DeleteBuilderBase implements DeleteBuilder {

        protected ExpressionBuilder where;

        protected TableNameBuilder table;

        public DeleteBuilderBase() {

        }

        @Override

        public void accept(Visitor visitor, VisitorFilter filter) {

            if( filter.accept(this) ) {

                visitor.visit(this);

            }

            if( this.table != null ) {

                this.table.accept(visitor, filter);

            }

            if( this.has_where() ) {

                this.where.accept(visitor, filter);

            }

        }

        @Override

        public ExpressionBuilder where() {

            if (this.where == null) {

                this.where = createExpressionBuilder();

            }

            return this.where;

        }

        @Override

        public TableNameBuilder table() {

            if( table == null ) {

                table = createTableNameBuilder();

            }

            return table;

        }

        @Override

        public boolean has_where() {

            return this.where != null;

        }

        @Override

        public String toString() {

            /*

             * DELETE FROM table_name

             * WHERE some_column=some_value; 

             */

            String sql;

            if( this.has_where() ) {

                sql = MessageFormat.format(

                        config.getString(SQLConfig.DELETE_FROM_table_WHERE_expresion),

                        this.table.toString(),

                        this.where.toString()

                );

            } else {

                sql = MessageFormat.format(

                        config.getString(SQLConfig.DELETE_FROM_table),

                        this.table.toString()

                );

            }

            return sql;

        }

    }

    public class AlterTableBuilderBase implements AlterTableBuilder {

        protected TableNameBuilder table;

        protected List<String> drops;

        protected List<ColumnDescriptorBuilderBase> adds;

        protected List<ColumnDescriptorBuilderBase> alters;

        protected List<Pair<String,String>> renames;

        public AlterTableBuilderBase() {

            this.drops = new ArrayList<>();

            this.adds = new ArrayList<>();

            this.alters = new ArrayList<>();

            this.renames = new ArrayList<>();

        }

        @Override

        public void accept(Visitor visitor, VisitorFilter filter) {

            if( filter.accept(this) ) {

                visitor.visit(this);

            }

            if( this.table != null ) {

                this.table.accept(visitor, filter);

            }

        }

        @Override

        public TableNameBuilder table() {

            if( table == null ) {

                table = createTableNameBuilder();

            }

            return table;

        }

        @Override

        public AlterTableBuilder drop_column(String columnName) {

            this.drops.add(columnName);

            return this;

        }

        @Override

        public AlterTableBuilder add_column(String columnName, int type, int type_p, int type_s, boolean isPk, boolean isIndexed, boolean allowNulls, boolean isAutomatic, Object defaultValue) {

            if (isPk || isAutomatic) {

                allowNulls = false;

            }

            this.adds.add(new ColumnDescriptorBuilderBase(columnName, type, type_p, type_s, isPk, isIndexed, allowNulls, isAutomatic, defaultValue));

            return this;

        }

        @Override

        public AlterTableBuilder add_geometry_column(String columnName, int type, int subtype, IProjection proj, boolean isIndexed, boolean allowNulls) {

            if( StringUtils.isEmpty(columnName) ) {

                throw new IllegalArgumentException("Argument 'columnName' can't be empty.");

            }

            this.adds.add(new ColumnDescriptorBuilderBase(columnName, type, subtype, proj, isIndexed, allowNulls));

            return this;

        }

        @Override

        public AlterTableBuilder alter_column(String columnName, int type, int type_p, int type_s, boolean isPk, boolean isIndexed, boolean allowNulls, boolean isAutomatic, Object defaultValue) {

            if (isPk || isAutomatic) {

                allowNulls = false;

            }

            this.alters.add(new ColumnDescriptorBuilderBase(columnName, type, type_p, type_s, isPk, isIndexed, allowNulls, isAutomatic, defaultValue));

            return this;

        }

        @Override

        public AlterTableBuilder alter_geometry_column(String columnName, int type, int subtype, IProjection proj, boolean isIndexed, boolean allowNulls) {

            if( StringUtils.isEmpty(columnName) ) {

                throw new IllegalArgumentException("Argument 'columnName' can't be empty.");

            }

            this.alters.add(new ColumnDescriptorBuilderBase(columnName, type, subtype, proj, isIndexed, allowNulls));

            return this;

        }

        @Override

        public AlterTableBuilder rename_column(String source, String target) {

            this.renames.add(new ImmutablePair(source, target));

            return this;

        }

        @Override

        public String toString() {

            StringBuilder builder = new StringBuilder();

            boolean first = true;

            for (String sql : toStrings()) {

                if( StringUtils.isEmpty(sql) ) {

                    continue;

                }

                if (first) {

                    first = false;

                } else {

                    builder.append("; ");

                }

                builder.append(sql);