Application: gvSIG desktop

package org.gvsig.expressionevaluator.impl;

import java.text.MessageFormat;

import java.text.ParseException;

import java.text.SimpleDateFormat;

import java.util.ArrayList;

import java.util.Collections;

import java.util.Date;

import java.util.HashSet;

import java.util.List;

import java.util.Objects;

import java.util.Set;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.expressionevaluator.Code;

import org.gvsig.expressionevaluator.Expression;

import org.gvsig.expressionevaluator.ExpressionBuilder;

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

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

import org.gvsig.expressionevaluator.ExpressionEvaluatorLocator;

import org.gvsig.expressionevaluator.ExpressionEvaluatorManager;

import org.gvsig.expressionevaluator.ExpressionUtils;

import org.gvsig.expressionevaluator.Formatter;

import org.gvsig.expressionevaluator.ReprMethod;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dataTypes.Coercion;

import org.gvsig.tools.dataTypes.DataTypesManager;

@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_ISNULL = "( ({0}) IS NULL )";

    private static final String FORMAT_NOTISNULL = "( ({0}) IS NOT 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 void replace(Value target, Value replacement) {

            if( this.value == target ) {

                this.value = replacement;

            } else {

                this.value.replace(target, replacement);

            }

        }

        @Override

        public String toString() {

            return this.toString(formatter());

        }

        @Override

        public String toString(Formatter<Value> formatter) {

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

                return formatter.format(this);

            }

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

        }

    }

    public class VariableBase extends AbstractValue implements Variable {

        protected String name;

        protected ExpressionBuilder builder;

        public VariableBase(ExpressionBuilder builder, String name) {

            this.name = name;

            this.builder = builder;

        }

        @Override

        public String name() {

            return this.name;

        }

        @Override

        public String toString() {

            return this.toString(formatter());

        }

        @Override

        public String toString(Formatter<Value> formatter) {

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

                return formatter.format(this);

            }

            return this.builder.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 int type;

        public ParameterBase() {

            this.type = PARAMETER_TYPE_CONSTANT;

            this.name = null;

            this.value = null;

        }

        @Override

        public Parameter as_constant() {

            this.type = PARAMETER_TYPE_CONSTANT;

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

                this.value = this.name;

            }

            return this;

        }

        @Override

        public Parameter as_variable() {

            this.type = PARAMETER_TYPE_VARIABLE;

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

                this.name = (String) this.value;

            }

            return this;

        }

        @Override

        public String name() {

            switch (this.type) {

                case PARAMETER_TYPE_VARIABLE:

                    return this.name;

                case PARAMETER_TYPE_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 int type() {

            return this.type;

        }

        @Override

        public boolean is_constant() {

            return this.type == PARAMETER_TYPE_CONSTANT;

        }

        @Override

        public boolean is_variable() {

            return this.type == PARAMETER_TYPE_VARIABLE;

        }

        @Override

        public Parameter value(Object value) {

            this.value = value;

            return this;

        }

        @Override

        public Parameter name(String name) {

            this.type = PARAMETER_TYPE_VARIABLE;

            this.name = name;

            return this;

        }

        @Override

        public Object value() {

            try {

                switch (this.type) {

                    case PARAMETER_TYPE_CONSTANT:

                        return this.value;

                    case PARAMETER_TYPE_VARIABLE:

                    default:

                        return this.value;

                }

            } catch (Exception ex) {

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

            }

        }

        @Override

        public String toString() {

            return this.toString(formatter());

        }

        @Override

        public String toString(Formatter<Value> formatter) {

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

                return formatter.format(this);

            }

            switch (this.type) {

                case PARAMETER_TYPE_CONSTANT:

                    return Objects.toString(this.value);

                case PARAMETER_TYPE_VARIABLE:

                default:

                    return "?";

            }

        }

    }

    public class ConstantBase extends AbstractValue implements Constant {

        protected Object value;

        protected ExpressionBuilder builder;

        public ConstantBase(ExpressionBuilder builder, Object value) {

            this.value = value;

            this.builder = builder;

        }

        @Override

        public Object value() {

            return this.value;

        }

        @Override

        public String toString() {

            return this.toString(formatter());

        }

        @Override

        public String toString(Formatter<Value> formatter) {

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

                return formatter.format(this);

            }

            if( this.value==null ) {

                return "NULL";

            }

            if( this.value instanceof byte[] ) {

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

            }

            if (this.value instanceof String) {

                return this.builder.string((String) this.value);

            }

            if (this.value instanceof Boolean) {

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

                    return FORMAT_TRUE;

                } else {

                    return FORMAT_FALSE;

                }

            }

            ExpressionEvaluatorManager manager = ExpressionEvaluatorLocator.getManager();

            ReprMethod repr = manager.getReprMethod(this.value);            

            return repr.repr(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 void replace(Value target, Value replacement) {

            if( this.values == null ) {

                return;

            }

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

                Value theValue = values.get(i);

                if( target == theValue ) {

                    values.set(i, replacement);

                } else {

                    theValue.replace(target, replacement);

                }

            }

        }

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

        }

        @Override

        public String toString(Formatter<Value> formatter) {

            if( formatter!=null && 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 format(String format) {

          this.format = format;

          return this;

        }

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

            if( this.parameters!=null ) {

                for (Value argument : this.parameters) {

                    if( argument!=null ) {

                        argument.accept(visitor, filter);

                    }

                }

            }

        }

        @Override

        public void replace(Value target, Value replacement) {

          if( this.parameters!=null ) {

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

                Value argument = parameters.get(i);

                if( argument == target ) {

                    parameters.set(i, replacement);

                } else {

                    argument.replace(target, replacement);

                }

            }

          }

        }

        @Override

        public String toString() {

            return this.toString(formatter());

        }

        @Override

        public String toString(Formatter<Value> formatter) {

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

                return formatter.format(this);

            }

            if( this.format==null ) {

                StringBuilder builder = new StringBuilder();

                builder.append(name);

                builder.append("(");

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

                    boolean first = true;

                    for (Value argument : this.parameters) {

                        if( first ) {

                            first=false;

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

                        } else {

                            builder.append(", ");

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

                        }

                    }

                }

                builder.append(")");

                return builder.toString();

            }

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

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

                for (Value argument : this.parameters) {

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

                }

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

            } else {

                return this.format;

            }

        }

    }

    public class MethodBase extends FunctionBase implements Method {

        private 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 void replace(Value target, Value replacement) {

            if( this.instance == target ) {

                this.instance = replacement;

            } else {

                this.instance.replace(target, replacement);

            }

        }

        @Override

        public String toString(Formatter<Value> formatter) {

            if( formatter!=null && 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("(");

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

                boolean first = true;

                for (Value argument : this.parameters) {

                    if( first ) {

                        first=false;

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

                    } else {

                        builder.append(", ");

                        builder.append(argument.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 replace(Value target, Value replacement) {

            if( target == this.left ) {

                this.left = replacement;

            } else {

                this.left.replace(target, replacement);

            }

            if( target == this.right ) {

                this.right = replacement;

            } else {

                this.right.replace(target, replacement);

            }

        }

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

        }

        @Override

        public String toString(Formatter<Value> formatter) {

            if( formatter!=null && 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 Value value;

    protected ExpressionEvaluatorManager manager;

    protected Formatter<ExpressionBuilder.Value> formatter;

    public DefaultExpressionBuilder(ExpressionEvaluatorManager manager) {

        this.manager = manager;

    }

    @Override

    public Formatter<ExpressionBuilder.Value> formatter() {

      if( this.formatter == null ) {

        this.formatter = this.manager.getExpressionBuilderFormatter();

      }

      return this.formatter;

    }

    @Override

    public boolean isEmpty() {

        return value == null;

    }

    @Override

    public ExpressionBuilder createExpressionBuilder() {

        return new DefaultExpressionBuilder(this.manager);

    }

    @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 Constant bytearray(byte[] data) {

        return new ConstantBase(this, data);

    }

    @Override

    public Variable variable(String name) {

        return new VariableBase(this, name);

    }

    @Override

    public Variable column(String name) {

        return new VariableBase(this, 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(this, value);

    }

    @Override

    public Constant constant(Object value, Class theClass) {

      try {

        DataTypesManager dataTypeManager = ToolsLocator.getDataTypesManager();

        Coercion coercion = dataTypeManager.getDataType(theClass).getCoercion();

        return this.constant(coercion.coerce(value));

      } catch (Exception ex) {

        throw new RuntimeException("Can't coerce value ("+Objects.toString(value)+") to "+theClass.getSimpleName()+".", ex);

      }

    }

    @Override

    public Constant constant(Object value, int type) {

      try {

        DataTypesManager dataTypeManager = ToolsLocator.getDataTypesManager();

        Coercion coercion = dataTypeManager.getCoercion(type);

        return this.constant(coercion.coerce(value));

      } catch (Exception ex) {

        throw new RuntimeException("Can't coerce value ("+Objects.toString(value)+") to "+type+".", ex);

      }

    }

    @Override

    public Group group(Value value) {

        return new GroupBase(value);

    }

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

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

            vars.add((Variable) value1);

          }

        }, 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((Visitable value1) -> {

          params.add((Parameter) value1);

        }, 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 PARAMETER_TYPE_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 PARAMETER_TYPE_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 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 is_null(Value value) {

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

    }

    @Override

    public Function not_is_null(Value value) {

        return builtin_function("IS NOT 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 and(Expression leftOperand, Expression rightOperand) {

        return binaryOperator(

                OPERATOR_AND, 

                FORMAT_OPERATOR_AND, 

                leftOperand.getCode().toValue(), 

                rightOperand.getCode().toValue()

        );

    }

    @Override

    public BinaryOperator and(Expression leftOperand, Value rightOperand) {

        return binaryOperator(

                OPERATOR_AND, 

                FORMAT_OPERATOR_AND, 

                leftOperand.getCode().toValue(), 

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

        return binaryOperator(OPERATOR_LIKE, FORMAT_OPERATOR_LIKE, op1, op2);

    }

    @Override

    public BinaryOperator ilike(Value op1, Value op2) {

        return binaryOperator(OPERATOR_ILIKE, FORMAT_OPERATOR_ILIKE, op1, op2);

    }

    @Override

    public BinaryOperator add(Value op1, Value op2) {

        return binaryOperator(OPERATOR_ADD, FORMAT_OPERATOR_ADD, op1, op2);

    }

    @Override

    public BinaryOperator subst(Value op1, Value op2) {

        return binaryOperator(OPERATOR_SUBST, FORMAT_OPERATOR_SUBST, op1, op2);

    }

    @Override

    public BinaryOperator mult(Value op1, Value op2) {

        return binaryOperator(OPERATOR_MULT, FORMAT_OPERATOR_MULT, op1, op2);

    }

    @Override

    public BinaryOperator div(Value op1, Value op2) {

        return binaryOperator(OPERATOR_DIV, FORMAT_OPERATOR_DIV, op1, op2);

    }

    @Override

    public BinaryOperator concat(Value op1, Value op2) {

        return binaryOperator(OPERATOR_CONCAT, FORMAT_OPERATOR_CONCAT, op1, op2);

    }

    @Override

    public Function iif(Value condition, Value iftrue, Value iffalse) {

        return function(FUNCTION_IIF, condition, iftrue, iffalse);

    }

    @Override

    public Function ifnull(Value value, Value iftrue, Value iffalse) {

        return function(FUNCTION_IFNULL, value, iftrue, iffalse);

    }

    @Override

    public Function left(Value str, Value size) {

       return function(FUNCTION_LEFT, str, size);

    }

    @Override

    public Function right(Value str, Value len) {

       return function(FUNCTION_RIGHT, str, len);

    }

    @Override

    public Function locate(Value search, Value str, Value start) {

       return function(FUNCTION_LOCATE, search, str, start);

    }

    @Override

    public Function position(Value search, Value str) {

       return function(FUNCTION_POSITION, search, str);

    }

    @Override

    public Function lpad(Value str, Value len, Value padstr) {

       return function(FUNCTION_LPAD, str, len, padstr);

    }

    @Override

    public Function rpad(Value str, Value len, Value padstr) {

       return function(FUNCTION_RPAD, str, len, padstr);

    }

    @Override

    public Function ltrim(Value str) {

       return function(FUNCTION_LTRIM, str);

    }

    @Override

    public Function rtrim(Value str) {

       return function(FUNCTION_RTRIM, str);

    }

    @Override

    public Function trim(Value str) {

       return function(FUNCTION_TRIM, str);

    }

    @Override

    public Function repeat(Value str, Value size) {

       return function(FUNCTION_REPEAT, str, size);

    }

    @Override

    public Function replace(Value str, Value search, Value replstr) {

       return function(FUNCTION_REPLACE, str, search, replstr);

    }

    @Override

    public Function ascii(Value str) {

       return function(FUNCTION_ASCII, str);

    }

    @Override

    public Function lenght(Value str) {

       return function(FUNCTION_LENGHT, str);

    }

    @Override

    public Function instr(Value str, Value search, Value start) {

       return function(FUNCTION_INSTR, str, search, start);

    }

    @Override

    public Function lower(Value str) {

       return function(FUNCTION_LOWER, str);

    }

    @Override

    public Function upper(Value str) {

       return function(FUNCTION_UPPER, str);

    }

    @Override

    public Function space(Value size) {

       return function(FUNCTION_SPACE, size);

    }

    @Override

    public Function substring(Value str, Value start, Value len) {

       return function(FUNCTION_SUBSTRING, str, start, len);

    }

    @Override

    public Function acos(Value num) {

       return function(FUNCTION_ACOS, num);

    } 

    @Override

    public Function asin(Value num) {

       return function(FUNCTION_ASIN, num);

    }

    @Override

    public Function atan(Value num) {

       return function(FUNCTION_ATAN, num);

    }

    @Override

    public Function cos(Value num) {

       return function(FUNCTION_COS, num);

    }

    @Override

    public Function cosh(Value num) {

       return function(FUNCTION_COSH, num);

    }

    @Override

    public Function cot(Value num) {

       return function(FUNCTION_COT, num);

    }  

    @Override

    public Function bitand(Value num1, Value num2) {

       return function(FUNCTION_BITAND, num1, num2);

    } 

    @Override

    public Function bitor(Value num1, Value num2) {

       return function(FUNCTION_BITOR, num1, num2);

    }

    @Override

    public Function bitxor(Value num1, Value num2) {

       return function(FUNCTION_BITXOR, num1, num2);

    }

    @Override

    public Function ceil(Value num) {

       return function(FUNCTION_CEIL, num);

    }

    @Override

    public Function degrees(Value num) {

       return function(FUNCTION_DEGREES, num);

    }  

    @Override

    public Function exp(Value num) {

       return function(FUNCTION_EXP, num);

    }  

    @Override

    public Function floor(Value num) {

       return function(FUNCTION_FLOOR, num);

    }  

    @Override

    public Function log(Value num) {

       return function(FUNCTION_LOG, num);

    }  

    @Override

    public Function log10(Value num) {

       return function(FUNCTION_LOG10, num);

    }  

    @Override

    public Function pi() {

       return function(FUNCTION_PI);

    }

    @Override

    public Function abs(Value num) {

       return function(FUNCTION_ABS, num);

    }

    @Override

    public Function power(Value num) {

       return function(FUNCTION_POWER, num);

    }

    @Override

    public Function radians(Value num) {

       return function(FUNCTION_RADIANS, num);

    }

    @Override

    public Function rand(Value num) {

       return function(FUNCTION_RAND, num);

    }

    @Override

    public Function round(Value num) {

       return function(FUNCTION_ROUND, num);

    }

    @Override

    public Function sqrt(Value num) {

       return function(FUNCTION_SQRT, num);

    }