Application: gvSIG desktop

package org.gvsig.expressionevaluator.impl;

import java.text.MessageFormat;

import java.util.ArrayList;

import java.util.Collections;

import java.util.HashSet;

import java.util.List;

import java.util.Objects;

import java.util.Set;

import org.apache.commons.lang3.StringUtils;

import org.cresques.cts.IProjection;

import org.gvsig.expressionevaluator.Code;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.primitive.Envelope;

import org.gvsig.expressionevaluator.ExpressionBuilder;

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

import org.gvsig.expressionevaluator.ExpressionUtils;

import org.gvsig.expressionevaluator.Formatter;

import org.gvsig.fmap.geom.GeometryUtils;

@SuppressWarnings({"UseSpecificCatch" ,"OverridableMethodCallInConstructor"})

public class DefaultExpressionBuilder implements ExpressionBuilder {

    private static final String FORMAT_QUOTE_FOR_STRINGS = "'";

    private static final String FORMAT_QUOTE_FOR_IDENTIFIERS = "\"";

    private static final String FORMAT_TRUE = "TRUE";

    private static final String FORMAT_FALSE = "FALSE";

    private static final String FORMAT_GROUP = "( {0} )";

    private static final String FORMAT_ST_SRID = "ST_SRID({0})";

    private static final String FORMAT_ST_ASTEXT = "ST_AsText({0})";

    private static final String FORMAT_ST_ASBINARY = "ST_AsBinary({0})";

    private static final String FORMAT_ST_ASEWKB = "ST_AsEWKB({0})";

    private static final String FORMAT_ST_CONTAINS = "ST_Contains(({0}), ({1}))";

    private static final String FORMAT_ST_CROSSES = "ST_Crosses(({0}), ({1}))";

    private static final String FORMAT_ST_DISJOINT = "ST_Disjoint(({0}), ({1}))";

    private static final String FORMAT_ST_EQUALS = "ST_Equals(({0}), ({1}))";

    private static final String FORMAT_ST_ISCLOSED = "ST_IsClosed({0})";

    private static final String FORMAT_ST_OVERLAPS = "ST_Overlaps(({0}), ({1}))";

    private static final String FORMAT_ST_TOUCHES = "ST_Touches(({0}), ({1}))";

    private static final String FORMAT_ST_WITHIN = "ST_Within(({0}), ({1}))";

    private static final String FORMAT_ST_ENVELOPE = "ST_Envelope({0})";

    private static final String FORMAT_ST_INTERSECTS = "ST_Intersects(({0}), ({1}))";

    private static final String FORMAT_ST_GEOMFROMTEXT = "ST_GeomFromText(({0}), ({1}))";

    private static final String FORMAT_ST_GEOMFROMWKB = "ST_GeomFromWKB(({0}), ({1}))";

    private static final String FORMAT_ST_GEOMFROMEWKB = "ST_GeomFromEWKB(({0}), ({1}))";

    private static final String FORMAT_ST_SIMPLIFY = "ST_Simplify(({0}), ({1}))";

    private static final String FORMAT_ISNULL = "( ({0}) IS NULL )";

    private static final String FORMAT_NOTISNULL = "( ({0}) NOT IS NULL )";

    private static final String FORMAT_OPERATOR_NOT = "( NOT ({0}) )";

    private static final String FORMAT_OPERATOR_AND = "{0} AND {1}";

    private static final String FORMAT_OPERATOR_OR = "{0} OR {1}";

    private static final String FORMAT_OPERATOR_EQ = "( ({0}) = ({1}) )";

    private static final String FORMAT_OPERATOR_NE = "( ({0}) <> ({1}) )";

    private static final String FORMAT_OPERATOR_GT = "( ({0}) > ({1}) )";

    private static final String FORMAT_OPERATOR_GE = "( ({0}) >= ({1}) )";

    private static final String FORMAT_OPERATOR_LT = "( ({0}) < ({1}) )";

    private static final String FORMAT_OPERATOR_LE = "( ({0}) <= ({1}) )";

    private static final String FORMAT_OPERATOR_LIKE = "( ({0}) LIKE ({1}) )";

    private static final String FORMAT_OPERATOR_ILIKE = "( ({0}) ILIKE ({1}) )";

    private static final String FORMAT_OPERATOR_ADD = "{0} + {1}";

    private static final String FORMAT_OPERATOR_SUBST = "{0} - {1}";

    private static final String FORMAT_OPERATOR_MULT = "{0} * {1}";

    private static final String FORMAT_OPERATOR_DIV = "{0} / {1}";

    private static final String FORMAT_OPERATOR_CONCAT = "{0} || {1}";

    public class GroupBase extends AbstractValue implements Group {

        protected Value value;

        public GroupBase(Value value) {

            this.value = value;

        }

        @Override

        public Value value() {

            return value;

        }

        @Override

        public void accept(Visitor visitor, VisitorFilter filter) {

            super.accept(visitor, filter);

            this.value.accept(visitor, filter);

        }

        @Override

        public String toString() {

            return this.toString(EMPTY_FORMATTER);

        }

        @Override

        public String toString(Formatter<Value> formatter) {

            if( formatter.canApply(this) ) {

                return formatter.format(this);

            }

            return MessageFormat.format(FORMAT_GROUP, this.value.toString());

        }

    }

    public class VariableBase extends AbstractValue implements Variable {

        protected String name;

        public VariableBase(String name) {

            this.name = name;

        }

        @Override

        public String name() {

            return this.name;

        }

        @Override

        public String toString() {

            return this.toString(EMPTY_FORMATTER);

        }

        @Override

        public String toString(Formatter<Value> formatter) {

            if( formatter.canApply(this) ) {

                return formatter.format(this);

            }

            return 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 this.name.equals(((Variable) obj).name());

        }

        @Override

        public int hashCode() {

            int hash = 7;

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

            return hash;

        }

    }

    public class ParameterBase extends AbstractValue implements Parameter {

        protected String name;

        protected Object value;

        protected ParameterType type;

        protected Value srs;

        /*

        Para un parametre de tipo Geometria, el srs sera siempre un Constant

        excepto cuando se le asigne una geometria contante al parametro y esta

        tenga un SRS asignado. En este caso, tanto la geometria como el SRS

        se trataran como parametros.

        Si se quiere que el SRS sea un Parameter, se construira como tal y se 

        asignara a traves del metodo srs(Value srs).

        */

        public ParameterBase() {

            this.type = ParameterType.Constant;

            this.name = null;

            this.value = null;

        }

        @Override

        public void accept(Visitor visitor, VisitorFilter filter) {

            super.accept(visitor, filter);

            if (this.srs != null) {

                this.srs.accept(visitor, filter);

            }

        }

        @Override

        public Parameter as_geometry_variable() {

            this.type = ParameterType.Geometry;

            if (this.value == null && this.name != null) {

                this.value = this.name;

            }

            return this;

        }

        @Override

        public Parameter as_constant() {

            this.type = ParameterType.Constant;

            if (this.value == null && this.name != null) {

                this.value = this.name;

            }

            return this;

        }

        @Override

        public Parameter as_variable() {

            this.type = ParameterType.Variable;

            if (this.value != null && this.name == null) {

                this.name = (String) this.value;

            }

            return this;

        }

        @Override

        public Parameter srs(Value srs) {

            this.srs = srs;

            if( this.type == ParameterType.Variable ) {

                this.type = ParameterType.Geometry;

            }

            return this;

        }

        @Override

        public Parameter srs(IProjection srs) {

            this.srs = constant(srs_id(srs));

            if( this.type == ParameterType.Variable ) {

                this.type = ParameterType.Geometry;

            }

            return this;

        }

        @Override

        public String name() {

            switch (this.type) {

                case Variable:

                case Geometry:

                    return this.name;

                case Constant:

                    if (this.value == null) {

                        return null;

                    }

                    return this.value.toString();

                default:

                    if (this.name != null) {

                        return this.name;

                    }

                    if (this.value != null) {

                        return this.value.toString();

                    }

                    return null;

            }

        }

        @Override

        public boolean is_constant() {

            return this.type == ParameterType.Constant;

        }

        @Override

        public boolean is_geometry_variable() {

            return this.type == ParameterType.Geometry;

        }

        @Override

        public boolean is_variable() {

            return this.type == ParameterType.Variable;

        }

        @Override

        public Parameter value(Object value) {

            if( value instanceof Geometry ) {

                if( this.srs == null ) {

                    IProjection proj = ((Geometry)value).getProjection();

                    this.srs(parameter().value(proj));

                }

            }

            this.value = value;

            return this;

        }

        @Override

        public Parameter name(String name) {

            this.type = ParameterType.Variable;

            this.name = name;

            return this;

        }

        @Override

        public Object value() {

            try {

                switch (this.type) {

                    case Constant:

                        if( this.value instanceof Geometry ) {

                            Geometry geometry = (Geometry) this.value;

                            switch (geometry_support_type()) {

                                case EWKB:

                                    return GeometryUtils.toEWKB(geometry);

                                case WKB:

                                    return GeometryUtils.toWKB(geometry);

                                case WKT:

                                default:

                                    return GeometryUtils.toWKT(geometry);

                            }

                        } else if (this.value instanceof IProjection) {

                            return srs_id((IProjection) this.value);

                        }

                        return this.value;

                    case Variable:

                    case Geometry:

                    default:

                        return this.value;

                }

            } catch (Exception ex) {

                throw new RuntimeException("Can't get value from parameter.", ex);

            }

        }

        @Override

        public ParameterType type() {

            return this.type;

        }

        @Override

        public Value srs() {

            return this.srs;

        }

        @Override

        public String toString() {

            return this.toString(EMPTY_FORMATTER);

        }

        @Override

        public String toString(Formatter<Value> formatter) {

            if( formatter.canApply(this) ) {

                return formatter.format(this);

            }

            switch (this.type) {

                case Constant:

                    if( value instanceof Geometry ) {

                        switch (geometry_support_type()) {

                            case EWKB:

                                return MessageFormat.format(

                                    FORMAT_ST_GEOMFROMEWKB,

                                    "?",

                                    getSRS(formatter)

                                );

                            case WKB:

                                return MessageFormat.format(

                                    FORMAT_ST_GEOMFROMWKB,

                                    "?",

                                    getSRS(formatter)

                                );

                            case WKT:

                            default:

                                return MessageFormat.format(

                                    FORMAT_ST_GEOMFROMTEXT,

                                    "?",

                                    getSRS(formatter)

                                );

                        }

                    }

                case Variable:

                default:

                    return "?";

                case Geometry:

                    switch (geometry_support_type()) {

                        case EWKB:

                            return MessageFormat.format(

                                FORMAT_ST_GEOMFROMEWKB,

                                "?",

                                getSRS(formatter)

                            );

                        case WKB:

                            return MessageFormat.format(

                                FORMAT_ST_GEOMFROMWKB,

                                "?",

                                getSRS(formatter)

                            );

                        case WKT:

                        default:

                            return MessageFormat.format(

                                FORMAT_ST_GEOMFROMTEXT,

                                "?",

                                getSRS(formatter)

                            );

                    }

            }

        }

        private String getSRS(Formatter formatter) {

            if( this.srs!=null ) {

                return this.srs.toString(formatter);

            }

            if( this.value instanceof Geometry ) {

                IProjection proj = ((Geometry)this.value).getProjection();

                Object s = srs_id(proj);

                if( s == null ) {

                    throw new IllegalArgumentException("A parameter of type Geometry with an invalid SRS.");

                }

                return s.toString();

            }

            throw new IllegalArgumentException("The parameter of type Geometry need a SRS.");

        }

    }

    public class ConstantBase extends AbstractValue implements Constant {

        protected Object value;

        public ConstantBase(Object value) {

            this.value = value;

        }

        @Override

        public Object value() {

            return this.value;

        }

        @Override

        public String toString() {

            return this.toString(EMPTY_FORMATTER);

        }

        @Override

        public String toString(Formatter<Value> formatter) {

            if( formatter.canApply(this) ) {

                return formatter.format(this);

            }

            if( this.value==null ) {

                return "NULL";

            }

            if( this.value instanceof byte[] ) {

                return "DECODE('"+bytearray_hex((byte[])this.value)+"','hex')";

            }

            if (this.value instanceof String) {

                return string((String) this.value);

            }

            if( this.value instanceof Geometry ) {

                Geometry geometry = (Geometry) this.value;

                switch (geometry_support_type()) {

                    case EWKB:

                        return MessageFormat.format(

                                FORMAT_ST_GEOMFROMEWKB,

                                "DECODE('"+bytearray_hex(GeometryUtils.toEWKB(geometry))+"','hex')",

                                String.valueOf(srs_id(geometry.getProjection()))

                        );

                    case WKB:

                        return MessageFormat.format(

                                FORMAT_ST_GEOMFROMWKB,

                                "DECODE('"+bytearray_hex(GeometryUtils.toWKB(geometry))+"','hex')",

                                String.valueOf(srs_id(geometry.getProjection()))

                        );

                    case WKT:

                    default:

                        return MessageFormat.format(

                                FORMAT_ST_GEOMFROMTEXT,

                                string(GeometryUtils.toWKT(geometry)),

                                String.valueOf(srs_id(geometry.getProjection()))

                        );

                }

            }

            if( this.value instanceof IProjection ) {

                return Objects.toString(srs_id((IProjection)(this.value)));

            }

            if (this.value instanceof Boolean) {

                if (((Boolean) this.value)) {

                    return FORMAT_TRUE;

                } else {

                    return FORMAT_FALSE;

                }

            }

            return Objects.toString(this.value, "");

        }

    }

    public class CustomBase extends AbstractValue implements Custom {

        protected Object value;

        // Esto es para permitir declarar parametros y columnas en una seccion

        // custom.

        protected List<Value> values;

        public CustomBase(Object value) {

            this.value = value;

        }

        @Override

        public void accept(Visitor visitor, VisitorFilter filter) {

            super.accept(visitor, filter);

            if (this.values != null) {

                for (Value theValue : values) {

                    theValue.accept(visitor, filter);

                }

            }

        }

        @Override

        public Object value() {

            return this.value;

        }

        @Override

        public Custom add(Variable variable) {

            if (this.values == null) {

                this.values = new ArrayList<>();

            }

            this.values.add(variable);

            return this;

        }

        @Override

        public Custom add(Parameter parameter) {

            if (this.values == null) {

                this.values = new ArrayList<>();

            }

            this.values.add(parameter);

            return this;

        }

        @Override

        public String toString() {

            return this.toString(EMPTY_FORMATTER);

        }

        @Override

        public String toString(Formatter<Value> formatter) {

            if( formatter.canApply(this) ) {

                return formatter.format(this);

            }

            return Objects.toString(this.value, "");

        }

    }

    public class FunctionBase extends AbstractValue implements Function {

        protected String name;

        protected String format;

        protected List<Value> parameters;

        public FunctionBase(String name, String format) {

            this.name = name;

            this.format = format;

        }

        public FunctionBase(String name) {

            this(name,null);

        }

        @Override

        public List<Value> parameters() {

            if (this.parameters == null) {

                this.parameters = new ArrayList<>();

            }

            return this.parameters;

        }

        @Override

        public Function parameter(Value parameter) {

            this.parameters().add(parameter);

            return this;

        }

        @Override

        public String name() {

            return this.name;

        }

        @Override

        public void accept(Visitor visitor, VisitorFilter filter) {

            super.accept(visitor, filter);

            for (Value value : this.parameters) {

                value.accept(visitor, filter);

            }

        }

        @Override

        public String toString() {

            return this.toString(EMPTY_FORMATTER);

        }

        @Override

        public String toString(Formatter<Value> formatter) {

            if( formatter.canApply(this) ) {

                return formatter.format(this);

            }

            if( this.format==null ) {

                StringBuilder builder = new StringBuilder();

                builder.append(name);

                builder.append("(");

                if (this.parameters != null && !this.parameters.isEmpty()) {

                    boolean first = true;

                    for (Value value : this.parameters) {

                        if( first ) {

                            first=false;

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

                        } else {

                            builder.append(", ");

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

                        }

                    }

                }

                builder.append(")");

                return builder.toString();

            }

            if (this.parameters != null && !this.parameters.isEmpty()) {

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

                for (Value value : this.parameters) {

                    values.add(value.toString(formatter));

                }

                return MessageFormat.format(format, values.toArray());

            } else {

                return this.format;

            }

        }

    }

    public class MethodBase extends FunctionBase implements Method {

        private final Value instance;

        public MethodBase(Value instance, String name) {

            super(name);

            this.instance = instance;

        }

        @Override

        public Value instance() {

            return this.instance;

        }

        @Override

        public void accept(Visitor visitor, VisitorFilter filter) {

            this.instance.accept(visitor, filter);

            super.accept(visitor, filter);

        }

        @Override

        public String toString(Formatter<Value> formatter) {

            if( formatter.canApply(this) ) {

                return formatter.format(this);

            }

            StringBuilder builder = new StringBuilder();

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

            builder.append("->");

            builder.append(this.name());

            builder.append(name);

            builder.append("(");

            if (this.parameters != null && !this.parameters.isEmpty()) {

                boolean first = true;

                for (Value value : this.parameters) {

                    if( first ) {

                        first=false;

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

                    } else {

                        builder.append(", ");

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

                    }

                }

            }

            builder.append(")");

            return builder.toString();

        }

    }

    public class BinaryOperatorBase extends AbstractValue implements BinaryOperator {

        protected String name;

        protected String format;

        protected Value left;

        protected Value right;

        public BinaryOperatorBase(String name, String format) {

            this.name = name;

            this.format = format;

        }

        @Override

        public String name() {

            return this.name;

        }

        @Override

        public void accept(Visitor visitor, VisitorFilter filter) {

            super.accept(visitor, filter);

            this.left.accept(visitor, filter);

            this.right.accept(visitor, filter);

        }

        @Override

        public BinaryOperator left(Value operand) {

            this.left = operand;

            return this;

        }

        @Override

        public BinaryOperator right(Value operand) {

            this.right = operand;

            return this;

        }

        @Override

        public Value left() {

            return this.left;

        }

        @Override

        public Value right() {

            return this.right;

        }

        @Override

        public String toString() {

            return this.toString(EMPTY_FORMATTER);

        }

        @Override

        public String toString(Formatter<Value> formatter) {

            if( formatter.canApply(this) ) {

                return formatter.format(this);

            }

            if( this.format==null ) {

                StringBuilder builder = new StringBuilder();

                builder.append("(");

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

                builder.append(" ");

                builder.append(this.name);

                builder.append(" ");

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

                builder.append(")");

                return builder.toString();

            } else {

                return MessageFormat.format(

                        format,

                        this.left.toString(formatter),

                        this.right.toString(formatter)

                );

            }

        }

    }

    protected GeometrySupportType geometrySupportType;

    protected Value value;

    public DefaultExpressionBuilder() {

        this.geometrySupportType = GeometrySupportType.WKB;

    }

    @Override

    public boolean isEmpty() {

        return value == null;

    }

    @Override

    public ExpressionBuilder createExpressionBuilder() {

        return new DefaultExpressionBuilder();

    }

    @Override

    public GeometrySupportType geometry_support_type() {

        return this.geometrySupportType;

    }

    @Override

    public ExpressionBuilder geometry_support_type(GeometrySupportType geometrySupportType) {

        this.geometrySupportType = geometrySupportType;

        return this;

    }

    @Override

    public Value value() {

        return this.value;

    }

    @Override

    public ExpressionBuilder value(Value value) {

        this.value = value;

        return this;

    }

    @Override

    public String toString() {

        return this.value.toString();

    }

    @Override

    public String toString(Formatter<Value> formatter) {

        return this.value.toString(formatter);

    }

    @Override

    public Value toValue(String expression) {

        try {

            Code code = ExpressionUtils.compile(expression);

            return code.toValue(this);

        } catch(Throwable ex) {

            return custom(expression);

        }

    }

    @Override

    public void accept(Visitor visitor, VisitorFilter filter) {

        if( this.value == null) {

            return;

        }

        this.value.accept(visitor, filter);

    }

    @Override

    public String quote_for_identifiers() {

        return FORMAT_QUOTE_FOR_IDENTIFIERS;

    }

    @Override

    public String quote_for_strings() {

        return FORMAT_QUOTE_FOR_STRINGS;

    }

    @Override

    public String string(String s) {

        String quote = this.quote_for_strings();

//        No se porque no esta disponible wrapIfMissing

//        return StringUtils.wrapIfMissing(s,quote);

        if (s.startsWith(quote)) {

            return s;

        }

        return quote + StringUtils.replace(s,quote,quote+quote) + quote;

    }

    @Override

    public String identifier(String id) {

        String quote = this.quote_for_identifiers();

//        No se porque no esta disponible wrapIfMissing

//        return StringUtils.wrapIfMissing(id,quote);

        if (id.startsWith(quote)) {

            return id;

        }

        return quote + id + quote;

    }

    @Override

    public String bytearray_hex(byte[] data) {

        StringBuilder builder = new StringBuilder();

        for (byte abyte : data) {

            int v = abyte & 0xff;

            builder.append(String.format("%02x", v));

        }

        return builder.toString();

    }

    @Override

    public String bytearray_0x(byte[] data) {

        return "0x" + bytearray_hex(data);

    }

    @Override

    public String bytearray_x(byte[] data) {

        return "x'" + bytearray_hex(data) + "'";

    }

    @Override

    public Object srs_id(IProjection projection) {

        if( projection==null ) {

            return 0;

        }

        return ProjectionUtils.getCode(projection);

    }

    @Override

    public Constant bytearray(byte[] data) {

        return new ConstantBase(data);

    }

    @Override

    public Constant srs(IProjection projection) {

        return constant(projection);

    }

    @Override

    public Variable variable(String name) {

        return new VariableBase(name);

    }

    @Override

    public Variable column(String name) {

        return new VariableBase(name);

    }

    @Override

    public Parameter parameter(String name) {

        List<Parameter> parameters = this.parameters();

        for (Parameter parameter : parameters) {

            if( StringUtils.equalsIgnoreCase(name, parameter.name()) ) {

                return parameter;

            }

        }

        Parameter parameter = this.parameter();

        parameter.name(name);

        return parameter;

    }

    @Override

    public Parameter parameter() {

        return new ParameterBase();

    }

    @Override

    public Constant constant(Object value) {

        return new ConstantBase(value);

    }

    @Override

    public Group group(Value value) {

        return new GroupBase(value);

    }

    @Override

    public Constant geometry(Geometry geom, IProjection projection) {

        geom.setProjection(projection);

        return new ConstantBase(geom);

    }

    @Override

    public Constant geometry(Geometry geom) {

        if( geom.getProjection()==null ) {

            throw new IllegalArgumentException("The geometry does not have an associated projection. Use 'geometry(Geometry, IProjection)'.");

        }

        return new ConstantBase(geom);

    }

    @Override

    public Constant envelope(Envelope envelope, IProjection projection) {

        Geometry geom = envelope.getGeometry();

        geom.setProjection(projection);

        return new ConstantBase(geom);

    }

    @Override

    public Constant envelope(Envelope envelope) {

        if( envelope.getProjection()==null ) {

            throw new IllegalArgumentException("The envelope does not have an associated projection. Use 'envelope(Geometry, IProjection)'.");

        }

        Geometry geom = envelope.getGeometry();

        return new ConstantBase(geom);

    }

    @Override

    public Custom custom(Object value) {

        return new CustomBase(value);

    }

    @Override

    public Method method(Value instance, String name, Value... values) {

        MethodBase method = new MethodBase(instance, name);

        for (Value theValue : values) {

            method.parameter(theValue);

        }

        return method;

    }

    @Override

    public Function function(String name, Value... values) {

        FunctionBase func = new FunctionBase(name);

        for (Value theValue : values) {

            func.parameter(theValue);

        }

        return func;

    }

    public Function builtin_function(String name, String format, Value... values) {

        FunctionBase func = new FunctionBase(name, format);

        for (Value theValue : values) {

            func.parameter(theValue);

        }

        return func;

    }

    @Override

    public BinaryOperator binaryOperator(String name, Value leftOperand, Value rightOperand) {

        return binaryOperator(name, null, leftOperand, rightOperand);

    }

    public BinaryOperator binaryOperator(String name, String format, Value leftOperand, Value rightOperand) {

        BinaryOperator operator = new BinaryOperatorBase(name, format);

        operator.left(leftOperand);

        operator.right(rightOperand);

        return operator;

    }

    @Override

    public List<Variable> variables() {

        final Set<Variable> vars = new HashSet<>();

        this.accept(new Visitor() {

            @Override

            public void visit(Visitable value) {

                if( !vars.contains((Variable)value) ) {

                    vars.add((Variable)value);

                }

            }

        }, new ClassVisitorFilter(Variable.class));

        List<Variable> lvars = new ArrayList<>(vars);

        Collections.sort(lvars);

        return lvars;

    }

    @Override

    public List<Parameter> parameters() {

        final List<Parameter>  params = new ArrayList<>();

        this.accept(new Visitor() {

            @Override

            public void visit(Visitable value) {

                params.add((Parameter) value);

            }

        }, new ClassVisitorFilter(Parameter.class));

        return params;

    }

    @Override

    public List<String> parameters_names() {

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

        for (Parameter param : parameters()) {

            Object theValue = param.value();

            String s;

            switch(param.type()) {

                case Constant:

                    if( theValue==null ) {

                        s = "NULL";

                    } else if( theValue instanceof String ) {

                        s = "'" + (String)theValue + "'";

                    } else if( theValue instanceof byte[] ) {

                        s = bytearray_0x((byte[]) theValue);

                    } else {

                        s = theValue.toString();

                    }    

                    break;

                case Geometry:

                    if( param.name()==null ) {

                        s = bytearray_0x((byte[]) theValue);

                    } else {

                        s = "\"" + param.name() + "\"";

                    }

                    break;

                case Variable:

                default:

                    s = "\"" + param.name() + "\"";

            }

//            if( !params.contains(s) ) { // Ojo que deben ir todos, incluso duplicados.

                params.add(s);

//            }

        }

        // Collections.sort(params); Ojo, no deben ordenarse.

        return params;

    }

    @Override

    public List<String> variables_names() {

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

        for (Variable var : this.variables()) {

            vars.add(var.name());

        }

        Collections.sort(vars);

        return vars;

    }

    @Override

    public Function as_geometry(Value value) {

        return builtin_function(FUNCTION_ST_ASBINARY, FORMAT_ST_ASBINARY, value);

    }

    @Override

    public ExpressionBuilder set(Value value) {

        this.value = value;

        return this;

    }

    @Override

    public ExpressionBuilder and(Value value) {

        if (this.value == null) {

            return this.set(value);

        }

        BinaryOperator operator = binaryOperator(OPERATOR_AND, FORMAT_OPERATOR_AND, this.value, value);

        this.value = operator;

        return this;

    }

    @Override

    public ExpressionBuilder or(Value value) {

        if (this.value == null) {

            return this.set(value);

        }

        BinaryOperator operator = binaryOperator(OPERATOR_OR, FORMAT_OPERATOR_OR, this.value, value);

        this.value = operator;

        return this;

    }

    @Override

    public Function ST_Intersects(Value geom1, Value geom2) {

        return builtin_function(FUNCTION_ST_INTERSECTS, FORMAT_ST_INTERSECTS, geom1, geom2);

    }

    @Override

    public Function ST_SRID(Value geom) {

        return builtin_function(FUNCTION_ST_SRID, FORMAT_ST_SRID, geom);

    }

    @Override

    public Function ST_Envelope(Value geom) {

        return builtin_function(FUNCTION_ST_ENVELOPE, FORMAT_ST_ENVELOPE, geom);

    }

    @Override

    public Function ST_AsText(Value geom) {

        return builtin_function(FUNCTION_ST_ASTEXT, FORMAT_ST_ASTEXT, geom);

    }

    @Override

    public Function ST_AsBinary(Value geom) {

        return builtin_function(FUNCTION_ST_ASBINARY, FORMAT_ST_ASBINARY, geom);

    }

    @Override

    public Function ST_AsEWKB(Value geom) {

        return builtin_function(FUNCTION_ST_ASEWKB, FORMAT_ST_ASEWKB, geom);

    }

    @Override

    public Function ST_GeomFromText(Value geom, Value crs) {

        return builtin_function(FUNCTION_ST_GEOMFROMTEXT, FORMAT_ST_GEOMFROMTEXT, geom, crs);

    }

    @Override

    public Function ST_GeomFromWKB(Value geom, Value crs) {

        return builtin_function(FUNCTION_ST_GEOMFROMWKB, FORMAT_ST_GEOMFROMWKB, geom, crs);

    }

    @Override

    public Function ST_GeomFromEWKB(Value geom, Value crs) {

        return builtin_function(FUNCTION_ST_GEOMFROMEWKB, FORMAT_ST_GEOMFROMEWKB, geom, crs);

    }

    @Override

    public Function ST_Simplify(Value geom, Value tolerance) {

        return builtin_function(FUNCTION_ST_SIMPLIFY, FORMAT_ST_SIMPLIFY, tolerance);

    }

    @Override

    public Function ST_Disjoint(Value geom1, Value geom2) {

        return builtin_function(FUNCTION_ST_DISJOINT, FORMAT_ST_DISJOINT, geom1, geom2);

    }

    @Override

    public Function ST_Contains(Value geom1, Value geom2) {

        return builtin_function(FUNCTION_ST_CONTAINS, FORMAT_ST_CONTAINS, geom1, geom2);

    }

    @Override

    public Function ST_Equals(Value geom1, Value geom2) {

        return builtin_function(FUNCTION_ST_EQUALS, FORMAT_ST_EQUALS, geom1, geom2);

    }

    @Override

    public Function ST_Crosses(Value geom1, Value geom2) {

        return builtin_function(FUNCTION_ST_CROSSES, FORMAT_ST_CROSSES, geom1, geom2);

    }

    @Override

    public Function ST_IsClosed(Value geom) {

        return builtin_function(FUNCTION_ST_ISCLOSED, FORMAT_ST_ISCLOSED, geom);

    }

    @Override

    public Function ST_Overlaps(Value geom1, Value geom2) {

        return builtin_function(FUNCTION_ST_OVERLAPS, FORMAT_ST_OVERLAPS, geom1, geom2);

    }

    @Override

    public Function ST_Touches(Value geom1, Value geom2) {

        return builtin_function(FUNCTION_ST_TOUCHES, FORMAT_ST_TOUCHES, geom1, geom2);

    }

    @Override

    public Function ST_Within(Value geom1, Value geom2) {

        return builtin_function("ST_Within", FORMAT_ST_WITHIN, geom1, geom2);

    }

    @Override

    public Function is_null(Value value) {

        return builtin_function("IS NULL", FORMAT_ISNULL, value);

    }

    @Override

    public Function not_is_null(Value value) {

        return builtin_function("NOT IS NULL", FORMAT_NOTISNULL, value);

    }

    @Override

    public Function not(Value value) {

        return builtin_function(OPERATOR_NOT, FORMAT_OPERATOR_NOT, value);

    }

    @Override

    public BinaryOperator and(Value leftOperand, Value rightOperand) {

        return binaryOperator(OPERATOR_AND, FORMAT_OPERATOR_AND, leftOperand, rightOperand);

    }

    @Override

    public BinaryOperator or(Value leftOperand, Value rightOperand) {

        return binaryOperator(OPERATOR_OR, FORMAT_OPERATOR_OR, leftOperand, rightOperand);

    }

    @Override

    public BinaryOperator eq(Value leftOperand, Value rightOperand) {

        return binaryOperator("=", FORMAT_OPERATOR_EQ, leftOperand, rightOperand);

    }

    @Override

    public BinaryOperator ne(Value leftOperand, Value rightOperand) {

        return binaryOperator("<>", FORMAT_OPERATOR_NE, leftOperand, rightOperand);

    }

    @Override

    public BinaryOperator gt(Value op1, Value op2) {

        return binaryOperator(">", FORMAT_OPERATOR_GT, op1, op2);

    }

    @Override

    public BinaryOperator ge(Value op1, Value op2) {

        return binaryOperator(">=", FORMAT_OPERATOR_GE, op1, op2);

    }

    @Override

    public BinaryOperator lt(Value op1, Value op2) {

        return binaryOperator("<", FORMAT_OPERATOR_LT, op1, op2);

    }

    @Override

    public BinaryOperator le(Value op1, Value op2) {

        return binaryOperator("<=", FORMAT_OPERATOR_LE, op1, op2);

    }

    @Override

    public BinaryOperator like(Value op1, Value op2) {