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 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.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.slf4j.Logger;

import org.slf4j.LoggerFactory;

@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 abstract class AbstractStatementPart extends AbstractValue {

    }

    protected abstract class AbstractStatement extends AbstractStatementPart {

    }

    protected class ColumnDescriptorBase implements ColumnDescriptor {

        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 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.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_srsdbcode = null;

            this._isIndexed = false;

        }

        public ColumnDescriptorBase(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_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.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_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.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_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 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 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 {

//

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

        }

    }

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

            );

        }

    }

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

                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.canApply(this)) {

                return formatter.format(this);

            }

            if (!StringUtils.isEmpty(passthrough)) {

                return passthrough;

            }

            if (!StringUtils.isEmpty(subquery)) {

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

            }

            return this.tableName.toString(formatter);

        }

    }

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

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

            if (name.startsWith(quote)) {

                // Remove quotes

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

            }

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

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

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

        }

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

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

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

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

            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 (Privilege privilege : privileges) {

                if (first) {

                    first = false;

                } else {

                    builder.append(", ");

                }

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

            }

            String sql = MessageFormat.format(

                    STMT_GRANT_privileges_ON_table_TO_role,

                    builder.toString(),

                    table.toString(formatter),

                    role

            );

            return sql;

        }

    }

    public class GrantBuilderBase

            extends AbstractStatement

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

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

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

                sqls.add(role.toString(formatter));

            }

            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

            extends AbstractStatement

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