Application: gvSIG desktop

package org.gvsig.expressionevaluator.impl;

import java.text.MessageFormat;

import java.util.Objects;

import org.cresques.cts.IProjection;

import org.gvsig.expressionevaluator.ExpressionBuilder;

import org.gvsig.expressionevaluator.ExpressionBuilder.AbstractValue;

import org.gvsig.expressionevaluator.ExpressionBuilder.Constant;

import org.gvsig.expressionevaluator.ExpressionBuilder.Function;

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

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

import org.gvsig.expressionevaluator.ExpressionBuilder.Value;

import org.gvsig.expressionevaluator.ExpressionBuilder.Visitor;

import org.gvsig.expressionevaluator.ExpressionBuilder.VisitorFilter;

import org.gvsig.expressionevaluator.Formatter;

import org.gvsig.expressionevaluator.GeometryExpressionBuilderHelper;

import static org.gvsig.expressionevaluator.GeometryExpressionBuilderHelper.PARAMETER_TYPE_GEOMETRY;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryUtils;

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

public class DefaultGeometryExpressionBuilderHelper 

        implements GeometryExpressionBuilderHelper {

    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_FORCE2D = "ST_Force2D({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}))";

    public class GeometryParameterBase 

            extends AbstractValue 

            implements GeometryParameter {

        protected Value srs;

        protected GeometryExpressionBuilderHelper builder;

        protected String name;

        protected Object value;

        protected int type;

        /*

        Para un parametro 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.

        */

        public GeometryParameterBase(GeometryExpressionBuilderHelper builder) {

            this.type = PARAMETER_TYPE_CONSTANT;

            this.name = null;

            this.value = null;

            this.builder = builder;

        }

        @Override

        public Value clone() throws CloneNotSupportedException {

            GeometryParameterBase other = (GeometryParameterBase) super.clone();

            other.srs = (Value) org.gvsig.tools.lang.Cloneable.cloneQuietly(srs);

            return other;

        }

        @Override

        public void accept(Visitor visitor, VisitorFilter filter) {

            boolean visitChildren = true;

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

                visitor.visit(this);

            } else {

                visitChildren = !filter.skipChildren();

            }

            if (visitChildren) {

                if (this.srs != null) {

                    switch (this.type) {

                        case PARAMETER_TYPE_CONSTANT:

                        case PARAMETER_TYPE_GEOMETRY:

                            switch (this.builder.geometry_support_type()) {

                                case NATIVE:

                                    break;

                                case EWKB:

                                case WKB:

                                case WKT:

                                default:

                                    this.srs.accept(visitor, filter);

                            }

                            break;

                        case PARAMETER_TYPE_VARIABLE:

                        default:

                            // No esta claro si aqui debe hacerse un accept o no

                            this.srs.accept(visitor, filter);

                            break;

                    }

                }

            }

        }

        @Override

        public void replace(Value target, Value replacement) {

            if( this.srs == null){

                return;

            }

            if( this.srs == target ) {

                this.srs = replacement;

            } else {

                this.srs.replace(target, replacement);

            }

        }

        @Override

        public GeometryParameter value(Object value) {

            if( value instanceof Geometry ) {

                if( this.srs == null ) {

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

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

                }

            }

            this.value = value;

            return this;

        }

        @Override

        public GeometryParameter srs(IProjection srs) {

            this.srs = new ProjectionConstant(this.builder, srs);

            if( this.type == PARAMETER_TYPE_VARIABLE ) {

                this.type = PARAMETER_TYPE_GEOMETRY;

            }

            return this;

        }

        @Override

        public GeometryParameter srs(Value srs) {

            this.srs = srs;

            if( this.type == PARAMETER_TYPE_VARIABLE ) {

                this.type = PARAMETER_TYPE_GEOMETRY;

            }

            return this;

        }

        @Override

        public Value srs() {

            return this.srs;

        }

        @Override

        public Geometry geometry() {

            return (Geometry) this.value;

        }

        @Override

        public GeometryParameter as_constant() {

            this.type = PARAMETER_TYPE_CONSTANT;

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

                this.value = this.name;

            }

            return this;

        }

        @Override

        public GeometryParameter as_variable() {

            this.type = PARAMETER_TYPE_VARIABLE;

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

                this.name = (String) this.value;

            }

            return this;

        }

        @Override

        public GeometryParameter name(String name) {

            this.type = PARAMETER_TYPE_VARIABLE;

            this.name = name;

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

            this.type = PARAMETER_TYPE_GEOMETRY;

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

                this.value = this.name;

            }

            return this;

        }

        @Override

        public boolean is_geometry_variable() {

            return this.type == PARAMETER_TYPE_GEOMETRY;

        }

        @Override

        public Object value() {

            try {

                switch (this.type) {

                    case PARAMETER_TYPE_CONSTANT:

                        if( this.value instanceof Geometry ) {

                            switch (this.builder.geometry_support_type()) {

                                case NATIVE:

                                    return GeometryUtils.toEWKB(this.geometry());

                                case EWKB:

                                    return GeometryUtils.toEWKB(this.geometry());

                                case WKB:

                                    return GeometryUtils.toWKB(this.geometry());

                                case WKT:

                                default:

                                    return GeometryUtils.toWKT(this.geometry());

                            }

                        }

                        if( this.value instanceof IProjection ) {

                            return this.builder.srs_id((IProjection) this.value);

                        }

                        return this.value;

                    case PARAMETER_TYPE_VARIABLE:

                    case PARAMETER_TYPE_GEOMETRY:

                    default:

                        return this.value;

                }

            } catch (Exception ex) {

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

            }

        }

        @Override

        public String toString() {

          return this.toString(this.builder.builder().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:

                        if( this.value instanceof Geometry ) {

                            switch (this.builder.geometry_support_type()) {

                                case EWKB:

                                    return MessageFormat.format(

                                        FORMAT_ST_GEOMFROMEWKB,

                                        "?",

                                        this.getSRS(formatter)

                                    );

                                case WKB:

                                    return MessageFormat.format(

                                        FORMAT_ST_GEOMFROMWKB,

                                        "?",

                                        this.getSRS(formatter)

                                    );

                                case NATIVE:

                                    return MessageFormat.format("DECODE('{0}','hex')",

                                            this.builder.builder().bytearray_hex(

                                                GeometryUtils.toEWKB((Geometry) this.value)

                                            )

                                    );

                                case WKT:

                                default:

                                    return MessageFormat.format(

                                        FORMAT_ST_GEOMFROMTEXT,

                                        "?",

                                        this.getSRS(formatter)

                                    );

                            }

                        }

                case PARAMETER_TYPE_VARIABLE:

                default:

                    return "?";

                case PARAMETER_TYPE_GEOMETRY:

                    switch (this.builder.geometry_support_type()) {

                        case EWKB:

                            return MessageFormat.format(

                                FORMAT_ST_GEOMFROMEWKB,

                                "?",

                                getSRS(formatter)

                            );

                        case WKB:

                            return MessageFormat.format(

                                FORMAT_ST_GEOMFROMWKB,

                                "?",

                                getSRS(formatter)

                            );

                        case NATIVE:

                            return "?";

                        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 = this.builder.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 static class ProjectionParameterBase 

//            extends ParameterBase 

//            implements Parameter {

//        

//        protected GeometryExpressionBuilderHelper builder;

//

//        public ProjectionParameterBase(GeometryExpressionBuilderHelper builder) {

//            this.builder = builder;

//        }

//

//        @Override

//        public Parameter value(Object value) {

//            if( !(value instanceof IProjection) ) {

//                throw new IllegalArgumentException("Only IProjection are allowed.");

//            }

//            return super.value(value);

//        }

//

//        @Override

//        public Object value() {

//            try {

//                switch (this.type) {

//                    case PARAMETER_TYPE_CONSTANT:

//                        return this.builder.srs_id((IProjection) this.value);

//                    case PARAMETER_TYPE_VARIABLE:

//                    default:

//                        return this.value;

//                }

//            } catch (Exception ex) {

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

//            }

//        }        

//    }

    public static class GeometryConstant extends AbstractValue implements Constant {

        protected Geometry geometry;

        protected GeometryExpressionBuilderHelper builder;

        public GeometryConstant(GeometryExpressionBuilderHelper builder, Geometry geometry) {

            this.builder = builder;

            this.geometry = geometry;

        }

        @Override

        public String toString() {

          return this.toString(builder.builder().formatter()); 

        }

        @Override

        public String toString(Formatter<Value> formatter) {

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

                return formatter.format(this);

            }

            try {

                switch (this.builder.geometry_support_type()) {

                    case EWKB:

                        return MessageFormat.format(

                                FORMAT_ST_GEOMFROMEWKB,

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

                                this.getSRS()

                        );

                    case WKB:

                        return MessageFormat.format(

                                FORMAT_ST_GEOMFROMWKB,

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

                                this.getSRS()

                        );

                    case NATIVE:

                        return MessageFormat.format("DECODE('{0}','hex')",

                                this.builder.builder().bytearray_hex(

                                    GeometryUtils.toEWKB((Geometry) geometry)

                                )

                        );

                    case WKT:

                    default:

                        return MessageFormat.format(

                                FORMAT_ST_GEOMFROMTEXT,

                                this.builder.builder().string(GeometryUtils.toWKT(geometry)),

                                this.getSRS()

                        );

                }

            } catch(Throwable th) {

                throw th;

            }

        }

        @Override

        public Object value() {

            return this.geometry;

        }

        private String getSRS() {

            IProjection proj = this.geometry.getProjection();

            Object s = this.builder.srs_id(proj);

            if( s == null ) {

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

            }

            return s.toString();

        }

    }

    public static class ProjectionConstant extends AbstractValue implements Constant {

        protected IProjection projection;

        protected GeometryExpressionBuilderHelper builder;

        public ProjectionConstant(GeometryExpressionBuilderHelper builder, IProjection projection) {

            this.projection = projection;

            this.builder = builder;

        }

        @Override

        public String toString() {

          return this.toString(this.builder.builder().formatter()); 

        }

        @Override

        public String toString(Formatter<Value> formatter) {

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

                return formatter.format(this);

            }

            return Objects.toString(this.builder.srs_id(this.projection));

        }

        @Override

        public Object value() {

            return this.projection;

        }

    }

    protected GeometrySupportType geometrySupportType;

    protected ExpressionBuilder builder;

    public DefaultGeometryExpressionBuilderHelper(ExpressionBuilder builder) {

        this.builder = builder;

        this.geometrySupportType = GeometrySupportType.WKB;

    }

    public DefaultGeometryExpressionBuilderHelper() {

        this.geometrySupportType = GeometrySupportType.WKB;

    }

    @Override

    public ExpressionBuilder builder() {

        return this.builder;

    }

    @Override

    public GeometrySupportType geometry_support_type() {

        return this.geometrySupportType;

    }

    @Override

    public GeometryExpressionBuilderHelper geometry_support_type(GeometrySupportType geometrySupportType) {

        this.geometrySupportType = geometrySupportType;

        return this;

    }

    @Override

    public Object srs_id(IProjection projection) {

        if( projection==null ) {

            return 0;

        }

        return ProjectionUtils.getCode(projection);

    }

    @Override

    public Constant srs(IProjection projection) {

        if( projection == null ) {

            return this.builder.constant(null);

        }

        return new ProjectionConstant(this, projection);

    }

    @Override

    public Constant geometry(Geometry geom, IProjection projection) {

        if( geom == null ) {

            return this.builder.constant(null);

        }

        geom.setProjection(projection);

        return new GeometryConstant(this, geom);

    }

    @Override

    public Constant geometry(Geometry geom) {

        if( geom == null ) {

            return this.builder.constant(null);

        }

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

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

        }

        return new GeometryConstant(this, geom);

    }

    @Override

    public Constant envelope(Envelope envelope, IProjection projection) {

        if( envelope == null ) {

            return this.builder.constant(null);

        }

        Geometry geom = envelope.getGeometry();

        geom.setProjection(projection);

        return new GeometryConstant(this, geom);

    }

    @Override

    public Constant envelope(Envelope envelope) {

        if( envelope == null ) {

            return this.builder.constant(null);

        }

        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 GeometryConstant(this, geom);

    }

    @Override

    public GeometryParameter parameter() {

        GeometryParameterBase p = new GeometryParameterBase(this);

        return p;

    }

    @Override

    public GeometryParameter parameter(String name) {

        GeometryParameterBase p = new GeometryParameterBase(this);

        p.name(name);

        return p;

    }

    @Override

    public GeometryParameter parameter(Object value) {

        GeometryParameterBase p = new GeometryParameterBase(this);

        p.value(value);

        return p;

    }

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

        Function func = this.builder.function(name, values);

        func.format(format);

        return func;

    }    

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

        Function func = this.builder.function(name, values);

        return func;

    }    

    @Override

    public Function as_geometry(Value value) {

        return builtin_function(FUNCTION_ST_ASBINARY, FORMAT_ST_ASBINARY, value);

    }

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

        return builtin_function(FUNCTION_ST_FORCE2D, FORMAT_ST_FORCE2D, 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 ST_Area(Value geom) {

        return function("ST_Area", geom);

    }

    @Override

    public Function ST_Buffer(Value geom) {

        return function("ST_Buffer", geom);

    }

    @Override

    public Function ST_Buffer(Value geom, Value dist) {

        return function("ST_Buffer", geom, dist);

    }

    @Override

    public Function ST_Centroid(Value geom) {

        return function("ST_Centroid", geom);

    }

    @Override

    public Function ST_CoveredBy(Value geom1, Value geom2) {

        return function("ST_CoveredBy", geom1, geom2);

    }

    @Override

    public Function ST_Covers(Value geom1, Value geom2) {

        return function("ST_Covers", geom1, geom2);

    }

    @Override

    public Function ST_Diference(Value geom1, Value geom2) {

        return function("ST_Diference", geom1, geom2);

    }

    @Override

    public Function ST_Dimension(Value geom) {

        return function("ST_Dimension", geom);

    }

    @Override

    public Function ST_Distance(Value geom1, Value geom2) {

        return function("ST_Distance", geom1, geom2);

    }

    @Override

    public Function ST_EndPoint(Value geom) {

        return function("ST_EndPoint", geom);

    }

    @Override

    public Function ST_Intersection(Value geom1, Value geom2) {

        return function("ST_Intersection", geom1, geom2);

    }

    @Override

    public Function ST_IsSimple(Value geom) {

        return function("ST_IsSimple", geom);

    }

    @Override

    public Function ST_IsValid(Value geom) {

        return function("ST_IsValid", geom);

    }

    @Override

    public Function ST_NumGeometries(Value geom) {

        return function("ST_NumGeometries", geom);

    }

    @Override

    public Function ST_NumPoints(Value geom) {

        return function("ST_NumPoints", geom);

    }

    @Override

    public Function ST_Perimeter(Value geom) {

        return function("ST_Perimeter", geom);

    }

    @Override

    public Function ST_PointN(Value geom, Value n) {

        return function("ST_PointN", geom, n);

    }

    @Override

    public Function ST_StartPoint(Value geom) {

        return function("ST_StartPoint", geom);

    }

    @Override

    public Function ST_Union(Value geom1, Value geom2) {

        return function("ST_Union", geom1, geom2);

    }

    @Override

    public Function ST_X(Value geom) {

        return function("ST_X", geom);

    }

    @Override

    public Function ST_Y(Value geom) {

        return function("ST_Y", geom);

    }

    @Override

    public Function ST_Z(Value geom) {

        return function("ST_Z", geom);

    }

    @Override

    public Function ST_ExtentAggregate(Value geom) {

       return function(FUNCTION_ST_EXTENTAGGREGATE, geom);

    }

    @Override

    public Function ST_UnionAggregate(Value geom) {

       return function(FUNCTION_ST_UNIONAGGREGATE, geom);

    }

    @Override

    public Function ST_Point(Value x, Value y) {

       return function(FUNCTION_ST_POINT, x, y);

    }

    @Override

    public Function ST_MakePoint(Value x, Value y) {

       return function(FUNCTION_ST_MAKEPOINT, x, y);

    }

    @Override

    public Function ST_MakePoint(Value x, Value y, Value z) {

       return function(FUNCTION_ST_MAKEPOINT, x, y, z);

    }

    @Override

    public Function ST_MakePoint(Value x, Value y, Value z, Value m) {

       return function(FUNCTION_ST_MAKEPOINT, x, y, z, m);

    }

    @Override

    public Function ST_SetSRID(Value geom, Value srid) {

       return function(FUNCTION_ST_POINT, geom, srid);

    }

}