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

import org.apache.commons.lang3.StringUtils;

import org.cresques.cts.IProjection;

import org.gvsig.fmap.dal.ExpressionBuilder;

import org.gvsig.fmap.dal.ExpressionBuilder.BinaryOperator;

import org.gvsig.fmap.dal.ExpressionBuilder.Config;

import org.gvsig.fmap.dal.ExpressionBuilder.Constant;

import org.gvsig.fmap.dal.ExpressionBuilder.Custom;

import org.gvsig.fmap.dal.ExpressionBuilder.Function;

import org.gvsig.fmap.dal.ExpressionBuilder.GeometrySupportType;

import org.gvsig.fmap.dal.ExpressionBuilder.GeometryValue;

import org.gvsig.fmap.dal.ExpressionBuilder.Group;

import org.gvsig.fmap.dal.ExpressionBuilder.Parameter;

import org.gvsig.fmap.dal.ExpressionBuilder.ParameterType;

import org.gvsig.fmap.dal.ExpressionBuilder.Value;

import org.gvsig.fmap.dal.ExpressionBuilder.Variable;

import org.gvsig.fmap.dal.ExpressionBuilder.Visitable;

import org.gvsig.fmap.dal.ExpressionBuilder.Visitor;

import org.gvsig.fmap.dal.ExpressionBuilder.VisitorFilter;

import org.gvsig.fmap.geom.Geometry;

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

public class ExpressionBuilderBase implements ExpressionBuilder {

    public class ConfigBase implements Config {

        protected Map<String,Object> values;

        public ConfigBase() {

            this.values = new HashMap<>();

            this.values.put(has_spatial_functions,false);

            this.values.put(constant_true, "(1=1)");

            this.values.put(constant_false, "(1=2)");

            this.values.put(quote_for_identifiers, "\"");

            this.values.put(quote_for_strings, "'");

            this.values.put(geometry_type_support, GeometrySupportType.WKT);

            this.values.put(group, "( {0} )");

            this.values.put(Find_SRID , "Find_SRID(({0}), ({1}), ({2}))");

            this.values.put(ST_SRID , "ST_SRID({0})");

            this.values.put(ST_AsText , "ST_AsText({0})");

            this.values.put(ST_AsBinary, "ST_AsBinary({0})");

            this.values.put(ST_AsEWKB, "ST_AsWKB({0})");

            this.values.put(ST_Contains, "ST_Contains(({0}), ({1}))");            

            this.values.put(ST_Crosses,  "ST_Crosses(({0}), ({1}))");

            this.values.put(ST_Disjoint ,  "ST_Disjoint(({0}), ({1}))");

            this.values.put(ST_Equals ,  "ST_Equals(({0}), ({1}))");

            this.values.put(ST_IsClosed,  "ST_IsClosed({0})");

            this.values.put(ST_Overlaps,  "ST_Overlaps(({0}), ({1}))");

            this.values.put(ST_Touches,  "ST_Touches(({0}), ({1}))");

            this.values.put(ST_Within, "ST_Within(({0}), ({1}))");            

            this.values.put(ST_Envelope, "ST_Envelope({0})");

            this.values.put(ST_Intersects, "ST_Intersects(({0}), ({1}))");

            this.values.put(ST_GeomFromText, "ST_GeomFromText({0}, ({1}))");

            this.values.put(ST_GeomFromWKB, "ST_GeomFromWKB(({0}), ({1}))");

            this.values.put(ST_GeomFromEWKB, "ST_GeomFromEWKB(({0}), ({1}))");

            this.values.put(lcase, "LCASE({0})");

            this.values.put(ucase, "UCASE({0})");

            this.values.put(isNull, "( ({0}) IS NULL )");

            this.values.put(notIsNull, "( ({0}) NOT IS NULL )");

            this.values.put(operator_not, "( NOT ({0}) )");

            this.values.put(operator_AND, "{0} AND {1}");

            this.values.put(operator_OR, "{0} OR {1}");

            this.values.put(operator_EQ, "( ({0}) = ({1}) )");

            this.values.put(operator_NE, "( ({0}) <> ({1}) )");

            this.values.put(operator_GT, "( ({0}) > ({1}) )");

            this.values.put(operator_GE, "( ({0}) >= ({1}) )");

            this.values.put(operator_LT, "( ({0}) < ({1}) )");

            this.values.put(operator_LE, "( ({0}) <= ({1}) )");

            this.values.put(operator_LIKE, "( ({0}) LIKE ({1}) )");

            this.values.put(operator_ILIKE, "( ({0}) ILIKE ({1}) )");

            this.values.put(operator_add, "{0} + {1}");

            this.values.put(operator_subst, "{0} - {1}");

            this.values.put(operator_mult, "{0} * {1}");

            this.values.put(operator_div, "{0} / {1}");

            this.values.put(operator_concat, "{0} || {1}");

        }

        @Override

        public boolean has_functionality(String functionality) {

            Object x = this.values.get(functionality);

            if( x == null ) {

                return false;

            }

            if( x instanceof CharSequence && StringUtils.isEmpty((CharSequence) x) ) {

                return false;

            }

            return true;

        }

        @Override

        public void remove_functionality(String functionality) {

            this.values.remove(functionality);

        }

        @Override

        public boolean has_spatial_functions() {

            return this.getBoolean(has_spatial_functions);

        }

        @Override

        public GeometrySupportType getGeometryTypeSupport() {

            return (GeometrySupportType) this.get(geometry_type_support);

        }

        @Override

        public boolean getBoolean(String name) {

            return (boolean) this.values.get(name);

        }

        @Override

        public String getString(String name) {

            return (String) this.values.get(name);

        }

        @Override

        public Object get(String name) {

            return this.values.get(name);

        }

        @Override

        public void set(String name, Object value) {

            this.values.put(name,value);

        }

    }

    public abstract class AbstractValue implements Value {

        @Override

        public void accept(Visitor visitor, VisitorFilter filter) {

            if( filter == null || filter.accept(this) ) {

                visitor.visit(this);

            }

        }

    }

    public class ClassVisitorFilter implements VisitorFilter {

        private final Class classFilter;

        public ClassVisitorFilter(Class classFilter) {

            this.classFilter = classFilter;

        }

        @Override

        public boolean accept(Visitable visitable) {

            return classFilter.isInstance(visitable);

        }

    }

    public class GroupBase extends AbstractValue implements Group {

        protected Value value;

        public GroupBase(Value value) {

            this.value = value;

        }

        @Override

        public Value getValue() {

            return value;

        }

        @Override

        public void accept(Visitor visitor, VisitorFilter filter) {

            super.accept(visitor,filter);

            this.value.accept(visitor,filter);

        }

        @Override

        public String toString() {

            return MessageFormat.format(config.getString(Config.group), this.value.toString());

        }

    }

    public class VariableBase extends AbstractValue implements Variable {

        protected String name;

        public VariableBase(String name) {

            this.name = name;

        }

        @Override

        public String getName() {

            return this.name;

        }

        @Override

        public String toString() {

            return identifier(this.name);

        }

        @Override

        public int compareTo(Variable o) {

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

        }

        @Override

        public boolean equals(Object obj) {

            if( ! (obj instanceof Variable) ) {

                return false;

            }

            return this.name.equals(((Variable)obj).getName());

        }

        @Override

        public int hashCode() {

            int hash = 7;

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

            return hash;

        }

    }

    public class ParameterBase extends AbstractValue implements Parameter {

        protected Object value;

        protected ParameterType type;

        protected Value srs;

        public ParameterBase(Object value) {

            this.value = value;

            if( this.value instanceof String ) {

                this.type = ParameterType.Variable;

            } else {

                this.type = ParameterType.Constant;

            }

        }

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

            this.type = ParameterType.Geometry;

            return this;

        }

        @Override

        public Parameter as_constant() {

            this.type = ParameterType.Constant;

            return this;

        }

        @Override

        public Parameter as_variable() {

            this.type = ParameterType.Variable;

            return this;

        }

        @Override

        public Parameter srs(Value srs) {

            this.srs = srs;

            return this;

        }

        @Override

        public Parameter srs(IProjection srs) {

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

            return this;

        }

        @Override

        public String getName() {

            switch(this.type) {

                case Variable:

                case Geometry:

                    return (String) this.value;

                case Constant:

                default:

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

            try {

                switch(this.type) {

                    case Constant:

                        if( this.value instanceof Geometry ) {

                            switch( config.getGeometryTypeSupport() ) {

                                case EWKB:

                                    return bytearray(((Geometry)this.value).convertToEWKB());

                                case WKB:

                                    return bytearray(((Geometry)this.value).convertToWKB());

                                case WKT:

                                default:

                                    return ((Geometry)this.value).convertToWKT();

                            }

                        } else if( this.value instanceof IProjection ) {

                            return getSRSId((IProjection) this.value);

                        } 

                        return this.value;

                    case Variable:

                    case Geometry:

                    default:

                        return null;

                }

            } catch(Exception ex) {

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

            }

        }

        @Override

        public ParameterType getType() {

            return this.type;

        }

        @Override

        public Value getSRS() {

            return this.srs;

        }

        @Override

        public String toString() {

            switch(this.type) {

                case Constant:

                case Variable:

                default:

                    return "?";

                case Geometry:

                    switch( config.getGeometryTypeSupport() ) {

                        case EWKB:

                            return MessageFormat.format(

                                    config.getString(Config.ST_GeomFromEWKB),

                                    "?",

                                    String.valueOf(this.srs.toString())

                            );

                        case WKB:

                            return MessageFormat.format(

                                    config.getString(Config.ST_GeomFromWKB),

                                    "?",

                                    String.valueOf(this.srs.toString())

                            );

                        case WKT:

                        default:

                            return MessageFormat.format(

                                    config.getString(Config.ST_GeomFromText),

                                    "?",

                                    String.valueOf(this.srs.toString())

                            );                        

                    }                            

            }

        }        

    }

    public class ConstantBase extends AbstractValue implements Constant {

        protected Object value;

        public ConstantBase(Object value) {

            this.value = value;

        }

        @Override

        public Object getValue() {

            return this.value;

        }

        @Override

        public String toString() {

            if( this.value instanceof String ) {

                return string((String) this.value);

            }

            if( this.value instanceof Boolean ) {

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

                    return config.getString(Config.constant_true);

                } else {

                    return config.getString(Config.constant_false);

                }

            }

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

        }

    }

    public class CustomBase extends AbstractValue implements Custom {

        protected Object value;

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

        // custom.

        protected List<Value> values;

        public CustomBase(Object value) {

            this.value = value;

        }

        @Override

        public void accept(Visitor visitor, VisitorFilter filter) {

            super.accept(visitor, filter);

            if( this.values!=null ) {

                for (Value value : values) {

                    value.accept(visitor, filter);

                }

            }

        }

        @Override

        public Object getValue() {

            return this.value;

        }

        @Override

        public Custom add(Variable variable) {

            if( this.values==null ) {

                this.values = new ArrayList<>();

            }

            this.values.add(variable);

            return this;

        }

        @Override

        public Custom add(Parameter parameter) {

            if( this.values==null ) {

                this.values = new ArrayList<>();

            }

            this.values.add(parameter);

            return this;

        }

        @Override

        public String toString() {

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

        }

    }

    public class GeometryValueBase extends AbstractValue implements GeometryValue {

        protected Geometry geometry;

        protected IProjection projection;

        public GeometryValueBase(Geometry geometry, IProjection projection) {

            this.geometry = geometry;

            this.projection = projection;

        }

        @Override

        public Geometry getGeometry() {

            return this.geometry;

        }

        @Override

        public IProjection getSRS() {

            return this.projection;

        }

        @Override

        public String toString() {

            try {

                switch( config.getGeometryTypeSupport() ) {

                    case EWKB:

                        return MessageFormat.format(

                                config.getString(Config.ST_GeomFromEWKB),

                                bytearray(this.geometry.convertToEWKB()),

                                String.valueOf(getSRSId(this.projection))

                        );

                    case WKB:

                        return MessageFormat.format(

                                config.getString(Config.ST_GeomFromWKB),

                                bytearray(this.geometry.convertToWKB()),

                                String.valueOf(getSRSId(this.projection))

                        );

                    case WKT:

                    default:

                        return MessageFormat.format(

                                config.getString(Config.ST_GeomFromText),

                                string(this.geometry.convertToWKT()),

                                String.valueOf(getSRSId(this.projection))

                        );                        

                }

            } catch (Exception ex) {

                throw new RuntimeException("Can't convert geometry to string.",ex);

            }

        }

    } 

    public class FunctionBase extends AbstractValue implements Function {

        protected String name;

        protected String format;

        protected List<Value> parameters;

        public FunctionBase(String name, String format) {

            this.name = name;

            this.format = format;

        }

        @Override

        public List<Value> parameters() {

            if( this.parameters == null ) {

                this.parameters = new ArrayList<>();

            }

            return this.parameters;

        }        

        @Override

        public Function parameter(Value parameter) {

            this.parameters().add(parameter);

            return this;

        }

        @Override

        public String getName() {

            return this.name;

        }

        @Override

        public void accept(Visitor visitor, VisitorFilter filter) {

            super.accept(visitor,filter);

            for (Value value : this.parameters) {

                value.accept(visitor,filter);

            }

        }

        @Override

        public String toString() {

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

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

                for (Value value : this.parameters) {

                    values.add(value.toString());

                }

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

            } else {

                return this.format;

            }

        }

    }

    public class BinaryOperatorBase extends AbstractValue implements BinaryOperator {

        protected String name;

        protected String format;

        protected Value left;

        protected Value right;

        public BinaryOperatorBase(String name, String format) {

            this.name = name;

            this.format = format;

        }

        @Override

        public String getName() {

            return this.name;

        }

        @Override

        public void accept(Visitor visitor, VisitorFilter filter) {

            super.accept(visitor,filter);

            this.left.accept(visitor, filter);

            this.right.accept(visitor, filter);

        }

        @Override

        public BinaryOperator setLeft(Value operand) {

            this.left = operand;

            return this;

        }

        @Override

        public BinaryOperator setRight(Value operand) {

            this.right = operand;

            return this;

        }

        @Override

        public Value getLeft() {

            return this.left;

        }

        @Override

        public Value getRight() {

            return this.right;

        }

        @Override

        public String toString() {

            return MessageFormat.format(

                    format, 

                    this.left.toString(), 

                    this.right.toString()

            );

        }

    }

    protected Value value;

    protected Config config;

    public ExpressionBuilderBase() {

        this.config = new ConfigBase();

    }

    @Override

    public ExpressionBuilder createExpressionBuilder() {

        return new ExpressionBuilderBase();

    }

    @Override

    public Config getConfig() {

        return this.config;

    } 

    @Override

    public Value getValue() {

        return this.value;

    }

    @Override

    public ExpressionBuilder setValue(Value value) {

        this.value = value;

        return this;

    }

    @Override

    public String toString() {

        return this.value.toString();

    }

    @Override

    public void accept(Visitor visitor, VisitorFilter filter) {

        this.value.accept(visitor, filter);

    }

    @Override

    public boolean has_spatial_functions() {

        return this.config.getBoolean(Config.has_spatial_functions);

    }

    @Override

    public GeometrySupportType geometry_support_type() {

        return (GeometrySupportType) this.config.get(Config.geometry_type_support);

    }

    @Override

    public String string(String s) {

        String quote = this.config.getString(Config.quote_for_strings);

//        No se porque no esta disponible wrapIfMissing

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

        if (s.startsWith(quote)) {

            return s;

        }

        return quote + s + quote;

    }

    @Override

    public String identifier(String id) {

        String quote = this.config.getString(Config.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(byte[] data) {

        StringBuilder builder = new StringBuilder();

        builder.append("0x");

        for (byte abyte : data) {

            int v = abyte & 0xff;

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

        }

        return builder.toString();

    }

    @Override

    public int getSRSId(IProjection projection) {

        String abrev = projection.getAbrev();

        return Integer.valueOf(abrev.split(":")[1]);

    }

    @Override

    public Constant srs(IProjection projection) {

        return constant(getSRSId(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(Object  value) {

        return new ParameterBase(value);

    }

    @Override

    public Constant constant(Object value) {

        return new ConstantBase(value);

    }

    @Override

    public Group group(Value value) {

        return new GroupBase(value);

    }

    @Override

    public GeometryValue geometry(Geometry geom, IProjection projection) {

        return new GeometryValueBase(geom, projection);

    }

    @Override

    public GeometryValue envelope(Envelope envelope, IProjection projection) {

        return new GeometryValueBase(envelope.getGeometry(), projection);

    }

    @Override

    public Custom custom(Object value) {

        return new CustomBase(value);

    }

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

        FunctionBase func = new FunctionBase(name,format);

        for (Value value : values) {

            func.parameter(value);

        }

        return func;

    }

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

        BinaryOperator operator = new BinaryOperatorBase(name,format);

        operator.setLeft(leftOperand);

        operator.setRight(rightOperand);

        return operator;

    }

    @Override

    public List<Variable> getVariables() {

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

        this.accept(new Visitor() {

            @Override

            public void visit(Visitable value) {

                vars.add((Variable)value);

            }

        }, new ClassVisitorFilter(Variable.class) );

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

        Collections.sort(lvars);

        return lvars;

    }

    @Override

    public List<Parameter> getParameters() {

        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 Function getAsGeometry(Value value) {

        return function("ST_AsBinary", config.getString(Config.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("AND", config.getString(Config.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("OR", config.getString(Config.operator_OR), this.value, value);

        this.value = operator;

        return this;

    }

    @Override

    public Function Find_SRID(Value schema, Value table, Value column) {

        return function("Find_SRID", config.getString(Config.Find_SRID), schema, table, column);

    }

    @Override

    public Function ST_Intersects(Value geom1, Value geom2) {

        return function("ST_Intersects", config.getString(Config.ST_Intersects), geom1, geom2);

    }

    @Override

    public Function ST_SRID(Value geom) {

        return function("ST_SRID", config.getString(Config.ST_SRID), geom);

    }

    @Override

    public Function ST_Envelope(Value geom) {

        return function("ST_Envelope", config.getString(Config.ST_Envelope), geom);

    }

    @Override

    public Function ST_AsText(Value geom) {

        return function("ST_AsText", config.getString(Config.ST_AsText), geom);

    }

    @Override

    public Function ST_AsBinary(Value geom) {

        return function("ST_AsBinary", config.getString(Config.ST_AsBinary), geom);

    }

    @Override

    public Function ST_AsEWKB(Value geom) {

        return function("ST_AsEWKB", config.getString(Config.ST_AsEWKB), geom);

    }

    @Override

    public Function ST_GeomFromText(Value geom, Value crs) {

        return function("ST_GeomFromText", config.getString(Config.ST_GeomFromText), geom, crs);

    }

    @Override

    public Function ST_GeomFromWKB(Value geom, Value crs) {

        return function("ST_GeomFromWKB", config.getString(Config.ST_GeomFromWKB), geom, crs);

    }

    @Override

    public Function ST_GeomFromEWKB(Value geom, Value crs) {

        return function("ST_GeomFromEWKB", config.getString(Config.ST_GeomFromEWKB), geom, crs);

    }

    @Override

    public Function ST_Disjoint(Value geom1, Value geom2) {

        return function("ST_Disjoint", config.getString(Config.ST_Disjoint), geom1, geom2);

    }

    @Override

    public Function ST_Contains(Value geom1, Value geom2) {

        return function("ST_Contains", config.getString(Config.ST_Contains), geom1, geom2);

    }

    @Override

    public Function ST_Equals(Value geom1, Value geom2) {

        return function("ST_Equals", config.getString(Config.ST_Equals), geom1, geom2);

    }

    @Override

    public Function ST_Crosses(Value geom1, Value geom2) {

        return function("ST_Crosses", config.getString(Config.ST_Crosses), geom1, geom2);

    }

    @Override

    public Function ST_IsClosed(Value geom) {

        return function("ST_IsClosed", config.getString(Config.ST_IsClosed), geom);

    }

    @Override

    public Function ST_Overlaps(Value geom1, Value geom2) {

        return function("ST_Overlaps", config.getString(Config.ST_Overlaps), geom1, geom2);

    }

    @Override

    public Function ST_Touches(Value geom1, Value geom2) {

        return function("ST_Touches", config.getString(Config.ST_Touches), geom1, geom2);

    }

    @Override

    public Function ST_Within(Value geom1, Value geom2) {

        return function("ST_Within", config.getString(Config.ST_Within), geom1, geom2);

    }

    @Override

    public Function isNull(Value value) {

        return function("IS NULL", config.getString(Config.isNull), value);

    }

    @Override

    public Function notIsNull(Value value) {

        return function("NOT IS NULL", config.getString(Config.notIsNull), value);

    }

    @Override

    public Function not(Value value) {

        return function("NOT", config.getString(Config.operator_not), value);

    }

    @Override

    public Function lcase(Value s) {

        return function("LCASE", config.getString(Config.lcase), s);

    }

    @Override

    public Function ucase(Value s) {

        return function("UCASE", config.getString(Config.ucase), s);

    }

    @Override

    public BinaryOperator and(Value leftOperand, Value rightOperand) {

        return binaryOperator("AND", config.getString(Config.operator_AND), leftOperand, rightOperand);

    }

    @Override

    public BinaryOperator or(Value leftOperand, Value rightOperand) {

        return binaryOperator("OR", config.getString(Config.operator_OR), leftOperand, rightOperand);

    }

    @Override

    public BinaryOperator eq(Value leftOperand, Value rightOperand) {

        return binaryOperator("=", config.getString(Config.operator_EQ), leftOperand, rightOperand);

    }

    @Override

    public BinaryOperator ne(Value leftOperand, Value rightOperand) {

        return binaryOperator("<>", config.getString(Config.operator_NE), leftOperand, rightOperand);

    }    

    @Override

    public BinaryOperator gt(Value op1, Value op2) {

        return binaryOperator(">", config.getString(Config.operator_GT), op1, op2);

    }

    @Override

    public BinaryOperator ge(Value op1, Value op2) {

        return binaryOperator(">=", config.getString(Config.operator_GE), op1, op2);

    }

    @Override

    public BinaryOperator lt(Value op1, Value op2) {

        return binaryOperator("<", config.getString(Config.operator_LT), op1, op2);

    }

    @Override

    public BinaryOperator le(Value op1, Value op2) {

        return binaryOperator("<=", config.getString(Config.operator_LE), op1, op2);

    }

    @Override

    public BinaryOperator like(Value op1, Value op2) {

        return binaryOperator("LIKE", config.getString(Config.operator_LIKE), op1, op2);

    }

    @Override

    public BinaryOperator ilike(Value op1, Value op2) {

        return binaryOperator("ILIKE", config.getString(Config.operator_ILIKE), op1, op2);

    }

    @Override

    public BinaryOperator add(Value op1, Value op2) {

        return binaryOperator("ADD", config.getString(Config.operator_add), op1, op2);

    }

    @Override

    public BinaryOperator subst(Value op1, Value op2) {

        return binaryOperator("SUBST", config.getString(Config.operator_subst), op1, op2);

    }

    @Override

    public BinaryOperator mult(Value op1, Value op2) {

        return binaryOperator("MULT", config.getString(Config.operator_mult), op1, op2);

    }

    @Override

    public BinaryOperator div(Value op1, Value op2) {

        return binaryOperator("DIV", config.getString(Config.operator_div), op1, op2);

    }

    @Override

    public BinaryOperator concat(Value op1, Value op2) {

        return binaryOperator("CONCAT", config.getString(Config.operator_concat), op1, op2);

    }

}