Application: gvSIG desktop

import java.io.InputStream;

import java.net.URL;

import java.util.Locale;

import org.apache.commons.io.IOUtils;

import org.apache.commons.lang3.StringUtils;

import org.json.JSONArray;

import org.json.JSONObject;

@SuppressWarnings("UseSpecificCatch")

    private String group;

    private Range argc;

    private String description;

    private String[] descriptionArgs;

        load_from_resource();

        if( StringUtils.isBlank(name) ) {

            return;

        }

        if( this.alias.contains(name) ) {

            return;

        }

    private void load_from_resource() {

        String lang = Locale.getDefault().getLanguage();

        URL url = this.getClass().getResource("/org/gvsig/expressionevaluator/functions/"+lang+"/"+this.name()+".json");

        if( url == null ) {

            url = this.getClass().getResource("/org/gvsig/expressionevaluator/functions/en/"+this.name()+".json");

            if( url == null ) {

                return;

            }

        }

        InputStream is = null;

        JSONObject json;

        try {

            is = url.openStream();

            List<String> lines = IOUtils.readLines(is);

            json = new JSONObject(StringUtils.join(lines,  "\n"));

        } catch (Exception ex) {

            return;

        } finally {

            IOUtils.closeQuietly(is);

        }

        if( json.has("group") ) {

            this.group = json.getString("group");

        }

        if( json.has("description") ) {

            Object x = json.get("description");

            if( x instanceof String ) {

                this.description = (String) x;

            } else if( x instanceof JSONArray ) {

                StringBuilder builder = new StringBuilder();

                for (int i = 0; i < ((JSONArray)x).length(); i++) {

                    if( i>0 ) {

                        builder.append(" ");

                    }

                    builder.append(((JSONArray)x).getString(i));

                }

                this.description = builder.toString();

            } else {

                this.description = x.toString();

            }

            this.description = StringUtils.replace(

                    this.description, 

                    "@@@", 

                    url.toString()

            );

        }

        if( json.has("template") ) {

            this.template = json.getString("template");

        }

        if( json.has("returnType") ) {

            this.returnType = json.getString("returnType");

        }

        if( json.has("sqlCompatible") ) {

            this.sqlCompatible = json.getBoolean("sqlCompatible");

        }

        if( json.has("args") ) {

            JSONArray x = json.getJSONArray("args");

            String[] args = new String[x.length()];

            for (int i = 0; i < x.length(); i++) {

                args[i] = x.getString(i);

            }

            this.descriptionArgs = args;

        }

        if( json.has("alias") ) {

            JSONArray x = json.getJSONArray("alias");

            for (int i = 0; i < x.length(); i++) {

                this.addAlias(x.getString(i));

            }

        }

    }

    public ExpressionBuilder createExpressionBuilder();

package org.gvsig.expressionevaluator;

import java.util.List;

import org.cresques.cts.IProjection;

import org.gvsig.fmap.geom.Geometry;

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

public interface ExpressionBuilder {

    public enum GeometrySupportType {

        WKT,

        WKB,

        EWKB,

        NATIVE

    }

    public enum ParameterType {

        Variable,

        Constant,

        Geometry

    }

    public interface VisitorFilter {

        boolean accept(Visitable visitable);

    }

     public interface Visitor {

        public void visit(Visitable value);

    }

    public interface Visitable {

        public void accept(Visitor visitor, VisitorFilter filter);

    }

    public interface Config {

        public final static String has_spatial_functions = "has_spatial_functions";

        public final static String support_schemas = "support_schemas";

        public final static String quote_for_identifiers = "quote_for_identifiers";

        public final static String quote_for_strings = "quote_for_strings";

        public final static String geometry_type_support = "geometry_type_support";

        public final static String constant_true = "constant_true";

        public final static String constant_false = "constant_false";

        public final static String group = "group";

        public final static String attribute_crs = "crs";

        public final static String ST_SRID = "ST_SRID";

        public final static String ST_AsText = "ST_AsText";

        public final static String ST_AsBinary = "ST_AsBinary";

        public final static String ST_AsEWKB = "ST_AsEWKB";

        public final static String ST_Contains = "ST_Contains";

        public final static String ST_Crosses = "ST_Crosses";

        public final static String ST_Disjoint = "ST_Disjoint";

        public final static String ST_Equals = "ST_Equals";

        public final static String ST_IsClosed = "ST_IsClosed";

        public final static String ST_Overlaps = "ST_Overlaps";

        public final static String ST_Touches = "ST_Touches";

        public final static String ST_Within = "ST_Within";

        public final static String ST_Intersects = "ST_Intersects";

        public final static String ST_Envelope = "ST_Envelope";

        public final static String ST_GeomFromText = "ST_GeomFromText";

        public final static String ST_GeomFromWKB = "ST_GeomFromWKB";

        public final static String ST_GeomFromEWKB = "ST_GeomFromEWKB";

        public final static String ST_Simplify = "ST_Simplify";        

        public final static String lcase = "lcase";

        public final static String ucase = "ucase";

        public final static String isNull = "isNull";

        public final static String notIsNull = "notIsNull";

        public final static String operator_not = "operator_not";

        public final static String operator_AND = "operator_AND";

        public final static String operator_OR = "operator_OR";

        public final static String operator_EQ = "operator_EQ";

        public final static String operator_NE = "operator_NE";

        public final static String operator_GT = "operator_GT";

        public final static String operator_GE = "operator_GE";

        public final static String operator_LT = "operator_LT";

        public final static String operator_LE = "operator_LE";

        public final static String operator_LIKE = "operator_LIKE";

        public final static String operator_ILIKE = "operator_ILIKE";

        public final static String operator_add = "operator_add";

        public final static String operator_subst = "operator_subst";

        public final static String operator_mult = "operator_mult";

        public final static String operator_div = "operator_div";

        public final static String operator_concat = "operator_concat";

        public GeometrySupportType getGeometryTypeSupport();

        public boolean has_spatial_functions();

        public boolean has_functionality(String functionality);

        public void remove_functionality(String functionality);

        public boolean getBoolean(String name);

        public String getString(String name);

        public Object get(String name);

        public void set(String name, Object value);

    }

    public interface Value extends Visitable {

    }

    public interface Group extends Value {

        public Value getValue();

    }

    public interface Constant extends Value {

        public Object getValue();

    }

    public interface Custom extends Value {

        public Object getValue();

        public Custom add(Variable variable);

        public Custom add(Parameter parameter);

    }

    public interface GeometryValue extends Value {

        public Geometry getGeometry();

        public IProjection getSRS();

    }

    public interface ColumnDescriptor {

        public String getName();

        public int getType();

        public int getSize();

        public int getPrecision();

        public boolean isPrimaryKey();

        public boolean isIndexed();

        public boolean isAutomatic();

        boolean allowNulls();

        public Object getDefaultValue();

        public int getGeometryType();

        public int getGeometrySubtype();

        public Object getGeometrySRSId();

        public boolean isGeometry();

        public void setName(String name);

        public void setType(int type);

        public void setSize(int size);

        public void setPrecision(int precision);

        public void setIsPrimaryKey(boolean isPk);

        public void setIsAutomatic(boolean isAutomatic);

        public void setAllowNulls(boolean allowNulls);

        public void setDefaultValue(Object defaultValue);

        public void setGeometryType(int geom_type);

        public void setGeometrySubtype(int geom_subtype);

        public void setGeometrySRSId(Object geom_srsid);

    }

    public interface Variable extends Value, Comparable<Variable> {

        public String getName();

        public ColumnDescriptor getDescriptor();

    }

    public interface Parameter extends Value {

        public Parameter as_constant();

        public Parameter as_variable();        

        public Parameter as_geometry_variable();

        public Parameter srs(Value srs);

        public Parameter srs(IProjection srs);

        public String getName();

        public Object getValue();

        public Parameter value(Object value);

        public Parameter name(String value);

        public ParameterType getType();

        public Value getSRS();

        public boolean is_constant();

        public boolean is_variable();

        public boolean is_geometry_variable();        

    }

    public interface Parameters extends List<Parameter> {

        public Parameter get(String name);

    }

    public interface Function extends Value {

        public String getName();

        public List<Value> parameters();

        public Function parameter(Value parameter);

    }

    public interface BinaryOperator extends Value {

        public String getName();

        public Value getLeft();

        public Value getRight();

        public BinaryOperator setLeft(Value operand);

        public BinaryOperator setRight(Value operand);

    }

    public void accept(Visitor visitor, VisitorFilter filter);

    public List<Variable> getVariables();

    public Parameters getParameters();

    public boolean has_spatial_functions();

    public GeometrySupportType geometry_support_type();

    public String identifier(String name);

    public String bytearray(byte[] data);

    public String bytearray_hex(byte[] data);

    public String bytearray_0x(byte[] data);

    public String bytearray_x(byte[] data);

    public String string(String s);

    public Object getSRSId(IProjection projection);

    public Config getConfig();

    public Value getValue();

    public ExpressionBuilder setValue(Value value);

    public Variable variable(String name);

    public Variable column(String name); // Alias for variable(name)

    public Parameter parameter(String name);

    public Parameter parameter();

    public Constant constant(Object value);

    public Group group(Value group);

    public GeometryValue geometry(Geometry geom, IProjection projection);

    public GeometryValue geometry(Geometry geom);

    public GeometryValue envelope(Envelope envelope, IProjection projection);

    public GeometryValue envelope(Envelope envelope);

    public Custom custom(Object value);

    public Constant srs(IProjection projection);

    public Function getAsGeometry(Value value);

    public Function not(Value value);

    public Function notIsNull(Value value);

    public Function isNull(Value value);

    public Function ST_SRID(Value geom);

    public Function ST_AsText(Value geom);

    public Function ST_AsBinary(Value geom);

    public Function ST_AsEWKB(Value geom);

    public Function ST_Envelope(Value geom);

    public Function ST_GeomFromText(Value geom, Value crs);

    public Function ST_GeomFromWKB(Value geom, Value crs);

    public Function ST_GeomFromEWKB(Value geom, Value crs);

    public Function ST_Simplify(Value geom, Value tolerance);

    public Function ST_Equals(Value geom1, Value geom2);

    public Function ST_Intersects(Value geom1, Value geom2);

    public Function ST_Contains(Value geom1, Value geom2);

    public Function ST_Disjoint(Value geom1, Value geom2);

    public Function ST_Crosses(Value geom1, Value geom2);

    public Function ST_IsClosed(Value geom1);

    public Function ST_Overlaps(Value geom1, Value geom2);

    public Function ST_Touches(Value geom1, Value geom2);

    public Function ST_Within(Value geom1, Value geom2);

    public Function lcase(Value s);

    public Function ucase(Value s);

    public BinaryOperator and(Value op1, Value op2);

    public BinaryOperator or(Value op1, Value op2);

    public BinaryOperator eq(Value op1, Value op2);

    public BinaryOperator ne(Value op1, Value op2);

    public BinaryOperator gt(Value op1, Value op2);

    public BinaryOperator ge(Value op1, Value op2);

    public BinaryOperator lt(Value op1, Value op2);

    public BinaryOperator le(Value op1, Value op2);

    public BinaryOperator like(Value op1, Value op2);

    public BinaryOperator ilike(Value op1, Value op2);

    public BinaryOperator add(Value op1, Value op2);

    public BinaryOperator subst(Value op1, Value op2);

    public BinaryOperator mult(Value op1, Value op2);

    public BinaryOperator div(Value op1, Value op2);

    public BinaryOperator concat(Value op1, Value op2);

    public ExpressionBuilder set(Value value);

    public ExpressionBuilder and(Value value);

    public ExpressionBuilder or(Value value);

    public ExpressionBuilder createExpressionBuilder();

}

    <dependency>

        <groupId>org.json</groupId>

        <artifactId>json</artifactId>

        <scope>compile</scope>

    </dependency>

package org.gvsig.expresionevaluator.impl;

import java.util.ArrayList;

import java.util.List;

import junit.framework.TestCase;

import org.apache.commons.lang3.ArrayUtils;

import org.cresques.cts.IProjection;

import org.gvsig.expressionevaluator.ExpressionBuilder;

import org.gvsig.expressionevaluator.ExpressionBuilder.Config;

import org.gvsig.expressionevaluator.ExpressionBuilder.GeometrySupportType;

import org.gvsig.expressionevaluator.ExpressionBuilder.Parameter;

import org.gvsig.expressionevaluator.ExpressionBuilder.Variable;

import org.gvsig.expressionevaluator.impl.DefaultExpressionBuilder;

import org.gvsig.fmap.crs.CRSFactory;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

import org.gvsig.fmap.geom.exception.CreateGeometryException;

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

import org.gvsig.tools.library.impl.DefaultLibrariesInitializer;

public class TestExpressionBuilder extends TestCase {

    public TestExpressionBuilder(String testName) {

        super(testName);

    }

    @Override

    protected void setUp() throws Exception {

        super.setUp();

        new DefaultLibrariesInitializer().fullInitialize();

//        new ExpressionEvaluatorImplLibrary().initialize();

    }

    @Override

    protected void tearDown() throws Exception {

        super.tearDown();

    }

    // TODO add test methods here. The name must begin with 'test'. For example:

    // public void testHello() {}

    List<String> getVariableNames(ExpressionBuilder builder) {

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

        for (Variable var : builder.getVariables()) {

            vars.add(var.getName());

        }

        return vars;

    }

    List<String> getParameterNames(ExpressionBuilder builder) {

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

        for (Parameter param : builder.getParameters()) {

            String s;

            switch(param.getType()) {

                case Constant:

                    Object value = param.getValue();

                    if( value==null ) {

                        s = "null";

                    } else if( value instanceof String ) {

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

                    } else {

                        s = value.toString();

                    }    

                    break;

                case Geometry:

                case Variable:

                default:

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

            }

            params.add(s);

        }

        return params;

    }

    public void test2() {

        ExpressionBuilder builder = new DefaultExpressionBuilder();

        builder.and(

          builder.eq(

            builder.lcase(builder.variable("colum_name_c")),

            builder.parameter("colum_name_p")

          )

        );

        builder.and(

            builder.group(

                builder.or(

                    builder.like(

                        builder.lcase( builder.variable("uno")),

                        builder.constant("%10")

                    ),

                    builder.lt(

                        builder.variable("dos"),

                        builder.constant(-3.5)

                    )

                )

            )

        );

        builder.and(

                builder.ST_Intersects(

                    builder.variable("geom1"), 

                    builder.ST_Envelope(

                        builder.ST_GeomFromWKB(

                                builder.parameter("geom2"), 

                                builder.parameter().value(4326).as_constant()

                        )

                    )

                )

        );

        builder.and(

            builder.gt(

                builder.variable("tres"),

                builder.constant(123456789)

            )

        );

        assertEquals(

                "( (LCASE(\"colum_name_c\")) = (?) ) AND ( ( (LCASE(\"uno\")) LIKE ('%10') ) OR ( (\"dos\") < (-3.5) ) ) AND ST_Intersects((\"geom1\"), (ST_Envelope(ST_GeomFromWKB((?), (?))))) AND ( (\"tres\") > (123456789) )",

                builder.toString()

        );

        assertEquals(

                "[colum_name_c, dos, geom1, tres, uno]",

                ArrayUtils.toString(getVariableNames(builder))

        );

        assertEquals(

                "[\"colum_name_p\", \"geom2\", 4326]",

                ArrayUtils.toString(getParameterNames(builder))

        );

    }

    public void test3() throws CreateGeometryException {

        ExpressionBuilder builder = new DefaultExpressionBuilder();

        GeometryManager geometryManager = GeometryLocator.getGeometryManager();

        IProjection proj = CRSFactory.getCRS("EPSG:4326");

        Point point = geometryManager.createPoint(10, 20, Geometry.SUBTYPES.GEOM2D);

        builder.set(        

            builder.ST_Intersects(

              builder.geometry(point,proj),

              builder.variable("the_geom")

            )

        );

        builder.getConfig().set(Config.geometry_type_support, GeometrySupportType.WKT);

        System.out.println(builder.toString());

        assertEquals(

                "ST_Intersects((ST_GeomFromText('POINT (10 20)', (4326))), (\"the_geom\"))",

                builder.toString()

        );

        builder.getConfig().set(Config.geometry_type_support, GeometrySupportType.WKB);

        System.out.println(builder.toString());

        assertEquals(

                "ST_Intersects((ST_GeomFromWKB((DECODE('000000000140240000000000004034000000000000','hex')), (4326))), (\"the_geom\"))",

                builder.toString()

        );

        assertEquals(

                "[the_geom]",

                ArrayUtils.toString(getVariableNames(builder))

        );

        assertEquals(

                "[]",

                ArrayUtils.toString(getParameterNames(builder))

        );

    }

    public void test4() throws CreateGeometryException {

        ExpressionBuilder builder = new DefaultExpressionBuilder();

        IProjection proj = CRSFactory.getCRS("EPSG:4326");

        builder.and(

                builder.ST_Intersects(

                    builder.variable("geom1"), 

                    builder.ST_Envelope(

                        builder.ST_GeomFromWKB(

                                builder.parameter("geom2"), 

                                builder.parameter().value(proj).as_constant()

                        )

                    )

                )

        );

        System.out.println(builder.toString());

        assertEquals(

                "ST_Intersects((\"geom1\"), (ST_Envelope(ST_GeomFromWKB((?), (?)))))",

                builder.toString()

        );

        assertEquals(

                "[geom1]",

                ArrayUtils.toString(getVariableNames(builder))

        );

        assertEquals(

                "[\"geom2\", 4326]",

                ArrayUtils.toString(getParameterNames(builder))

        );

    }

    public void test5() throws CreateGeometryException {

        ExpressionBuilder builder = new DefaultExpressionBuilder();

        IProjection proj = CRSFactory.getCRS("EPSG:4326");

        builder.and(

                builder.eq(

                        builder.ST_SRID( builder.variable("geom") ),

                        builder.srs(proj)

                )

        );

        System.out.println(builder.toString());

        assertEquals(

                "( (ST_SRID(\"geom\")) = (4326) )",

                builder.toString()

        );

        assertEquals(

                "[geom]",

                ArrayUtils.toString(getVariableNames(builder))

        );

        assertEquals(

                "[]",

                ArrayUtils.toString(getParameterNames(builder))

        );

    }

}

package org.gvsig.expresionevaluator.impl;

import static junit.framework.Assert.assertEquals;

import junit.framework.TestCase;

import org.gvsig.expressionevaluator.impl.ExpressionEvaluatorImplLibrary;

import org.gvsig.expressionevaluator.Function;

import org.gvsig.expressionevaluator.impl.function.numeric.ACosFunction;

import org.gvsig.expressionevaluator.impl.function.spatial.STAreaFunction;

/**

 *

 * @author jjdelcerro

 */

public class TestLoadResource extends TestCase {

    public TestLoadResource(String testName) {

        super(testName);

    }

    @Override

    protected void setUp() throws Exception {

        super.setUp();

        new ExpressionEvaluatorImplLibrary().initialize();

    }

    @Override

    protected void tearDown() throws Exception {

        super.tearDown();

    }

    // TODO add test methods here. The name must begin with 'test'. For example:

    // public void testHello() {}

    public void testFunctionExpression1() {

        Function fn = new STAreaFunction();

        assertEquals("ST_Area({{geometry}})", fn.template());

    }    

}

        assertEquals("\"precio\"", code.toString());

        assertEquals("\"precio\"", code.toString());

        assertEquals("\"precio\"", code.toString());

        assertEquals(operatorName+"(\"precio\", 23)", code.toString());

        assertEquals("+(+(+(\"precio\", *(10, 2)), 20), 30)", code.toString());

        assertEquals("+(+(*(+(\"precio\", 10), 2), 20), 30)", code.toString());

        assertEquals("+(\"precio\", abs(10))", code.toString());

        assertEquals("+(\"precio\", abs(-10))", code.toString());

        assertEquals("+(\"precio\", PI())", code.toString());

        assertEquals("+(\"precio\", CEIL(PI()))", code.toString());

        assertEquals("CONCAT(\"precio\", ' euros')", code.toString());

        assertEquals("=(\"NOMBRE03\", 'Torre d'En Besora (la)')", code.toString());

        assertEquals("=(\"1990\", 0.168873933773767)", code.toString());

        assertEquals("=(\"1990\", \"precio\")", code.toString());

        assertEquals("ST_Area(\"GEOMETRY\")", code.toString());

package org.gvsig.expresionevaluator.impl;

import static junit.framework.Assert.assertEquals;

import junit.framework.TestCase;

import org.cresques.cts.IProjection;

import org.gvsig.expressionevaluator.Code;

import org.gvsig.expressionevaluator.ExpressionBuilder;

import org.gvsig.expressionevaluator.ExpressionBuilder.Config;

import org.gvsig.expressionevaluator.ExpressionBuilder.GeometrySupportType;

import org.gvsig.expressionevaluator.LexicalAnalyzer;

import org.gvsig.expressionevaluator.impl.DefaultCompiler;

import org.gvsig.expressionevaluator.impl.DefaultExpressionBuilder;

import org.gvsig.expressionevaluator.impl.SQLLexicalAnalyzer;

import org.gvsig.fmap.crs.CRSFactory;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

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

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

import org.gvsig.tools.library.impl.DefaultLibrariesInitializer;

import org.gvsig.expressionevaluator.Compiler;

import org.gvsig.expressionevaluator.ExpressionBuilder.Value;

import org.gvsig.expressionevaluator.Interpreter;

import org.gvsig.expressionevaluator.MutableSymbolTable;

import org.gvsig.expressionevaluator.SymbolTable;

import org.gvsig.expressionevaluator.impl.DefaultInterpreter;

import org.gvsig.expressionevaluator.impl.DefaultSymbolTable;

import org.gvsig.fmap.geom.exception.CreateGeometryException;

public class TestCase1 extends TestCase {

    public TestCase1(String testName) {

        super(testName);

    }

    @Override

    protected void setUp() throws Exception {

        super.setUp();

        new DefaultLibrariesInitializer().fullInitialize();

//        new ExpressionEvaluatorImplLibrary().initialize();

    }

    @Override

    protected void tearDown() throws Exception {

        super.tearDown();

    }

    // TODO add test methods here. The name must begin with 'test'. For example:

    // public void testHello() {}

    protected LexicalAnalyzer createLexicalAnalyzer() {

        SQLLexicalAnalyzer lexer = new SQLLexicalAnalyzer();

        return lexer;

    }

    protected Compiler createCompiler() {

        Compiler compiler = new DefaultCompiler();

        compiler.setLexicalAnalyzer(createLexicalAnalyzer());

        return compiler;

    }

    protected MutableSymbolTable createSymbolTable() {

        DefaultSymbolTable symbolTable = new DefaultSymbolTable();

        return symbolTable;

    }

    protected Interpreter createInterpreter(SymbolTable symbolTable) {

        Interpreter interpreter = new DefaultInterpreter();

        interpreter.setSymbolTable(symbolTable);

        return interpreter;

    }

    private String createExpr1() {

        ExpressionBuilder builder = new DefaultExpressionBuilder();

        Value expr1 = builder.gt(

                builder.column("campo1"),

                builder.constant(10)

        );

        System.out.println(expr1.toString());

        assertEquals(

                "( (\"campo1\") > (10) )",

                expr1.toString()

        );

        return expr1.toString();

    }

    private Polygon createPolygon() throws CreateGeometryException {

        GeometryManager geometryManager = GeometryLocator.getGeometryManager();

        IProjection proj = CRSFactory.getCRS("EPSG:4326");

        Polygon polygon = geometryManager.createPolygon(Geometry.SUBTYPES.GEOM2D);

        polygon.addVertex(0, 0);

        polygon.addVertex(0, 100);

        polygon.addVertex(100, 100);

        polygon.addVertex(100, 0);

        polygon.addVertex(0, 0);

        polygon.setProjection(proj);

        return polygon;

    }

    private Geometry createPoint(double x, double y) throws CreateGeometryException {

        GeometryManager geometryManager = GeometryLocator.getGeometryManager();

        IProjection proj = CRSFactory.getCRS("EPSG:4326");

        Point point = geometryManager.createPoint(x, y, Geometry.SUBTYPES.GEOM2D);

        point.setProjection(proj);

        return point;

    }

    public void testBuildExpression() throws Exception {

        ExpressionBuilder builder = new DefaultExpressionBuilder();

        Value expr2 = builder.and(

                builder.custom(this.createExpr1()),

                builder.ST_Intersects(

                        builder.geometry(createPolygon()),

                        builder.column("GEOMETRY")

                )

        );

        builder.getConfig().set(Config.geometry_type_support, GeometrySupportType.WKT);

        System.out.println(expr2.toString());

        assertEquals(

                "( (\"campo1\") > (10) ) AND ST_Intersects((ST_GeomFromText('POLYGON ((0 0, 0 100, 100 100, 100 0, 0 0))', (4326))), (\"GEOMETRY\"))",

                expr2.toString()

        );

        builder.getConfig().set(Config.geometry_type_support, GeometrySupportType.WKB);

        System.out.println(expr2.toString());

        assertEquals(

                "( (\"campo1\") > (10) ) AND ST_Intersects((ST_GeomFromWKB((DECODE('000000000300000001000000050000000000000000000000000000000000000000000000004059000000000000405900000000000040590000000000004059000000000000000000000000000000000000000000000000000000000000','hex')), (4326))), (\"GEOMETRY\"))",

                expr2.toString()

        );

    }

    public void testCompileExpression() throws Exception {

        IProjection proj = CRSFactory.getCRS("EPSG:4326");

        ExpressionBuilder builder = new DefaultExpressionBuilder();

        Value expr2 = builder.and(

              builder.custom(this.createExpr1()),

              builder.ST_Intersects(

                builder.geometry(createPolygon()),

                builder.column("GEOMETRY")

              )

        );

        Compiler compiler = createCompiler();

        Code code;

        builder.getConfig().set(Config.geometry_type_support, GeometrySupportType.WKT);

        code = compiler.compileExpression(expr2.toString());

        System.out.println(code.toString());

        assertEquals(

                "and(>(\"campo1\", 10), ST_Intersects(ST_GeomFromText('POLYGON ((0 0, 0 100, 100 100, 100 0, 0 0))', 4326), \"GEOMETRY\"))", 

                code.toString()

        );

        builder.getConfig().set(Config.geometry_type_support, GeometrySupportType.WKB);

        code = compiler.compileExpression(expr2.toString());

        System.out.println(code.toString());

        assertEquals(

                "and(>(\"campo1\", 10), ST_Intersects(ST_GeomFromWKB(DECODE('000000000300000001000000050000000000000000000000000000000000000000000000004059000000000000405900000000000040590000000000004059000000000000000000000000000000000000000000000000000000000000', 'hex'), 4326), \"GEOMETRY\"))", 

                code.toString()

        );

    }

    public void testRunExpression() throws Exception {

        ExpressionBuilder builder = new DefaultExpressionBuilder();

        builder.getConfig().set(Config.geometry_type_support, GeometrySupportType.WKB);

        String expr2 = builder.and(

            builder.custom(this.createExpr1()),

            builder.ST_Intersects(

              builder.geometry(createPolygon()),

              builder.column("GEOMETRY")

            )

        ).toString();

        Compiler compiler = createCompiler();

        Code code = compiler.compileExpression(expr2);

        MutableSymbolTable symbolTable = createSymbolTable();

        Interpreter interpreter = createInterpreter(symbolTable);

        Object v;

        symbolTable.setVar("campo1", 11);

        symbolTable.setVar("GEOMETRY", createPoint(50, 50));

        v = interpreter.run(code);

        assertEquals(true, ((Boolean)v).booleanValue());

        symbolTable.setVar("campo1", 9);

        symbolTable.setVar("GEOMETRY", createPoint(50, 50));

        v = interpreter.run(code);

        assertEquals(false, ((Boolean)v).booleanValue());

        symbolTable.setVar("campo1", 11);

        symbolTable.setVar("GEOMETRY", createPoint(150, 50));

        v = interpreter.run(code);

        assertEquals(false, ((Boolean)v).booleanValue());

    }

}

{

    "name": "ST_Contains",

    "group": "OGC",

    "template": "ST_Contains({{geometryA}}, geometryB)",

    "args": [

        "geometryA - A geometry",

        "geometryB - A geometry"

    ],

    "description": "Geometry A contains Geometry B if and only if no points of B lie in the exterior of A, and at least one point of the interior of B lies in the interior of A. An important subtlety of this definition is that A does not contain its boundary, but A does contain itself.\nReturns TRUE if geometry B is completely inside geometry A. For this function to make sense, the source geometries must both be of the same coordinate projection, having the same SRID. ST_Contains is the inverse of ST_Within. So ST_Contains(A,B) implies ST_Within(B,A) except in the case of invalid geometries where the result is always false regardless or not defined.",

    "returnType": "Boolean"

}

{

    "name": "ACOS",

    "group": "Numeric",

    "template": "ACOS({{a}})",

    "args": [

        "value whose arc tangent is to be returned"

    ],

    "description": "Returns the arc cosine of a value; the returned angle is in the range 0.0 through pi.",

    "returnType": "Double"

}

{

    "name": "ST_Covers",

    "group": "OGC",

    "template": "ST_Covers({{geometryA}}, geometryB)",

    "args": [

        "geometryA - A geometry",

        "geometryB - A geometry"

    ],

    "description": "Returns TRUE if no point in Geometry B is outside Geometry A",

    "returnType": "Boolean"

}

{

    "name": "ST_Crosses",

    "group": "OGC",

    "template": "ST_Crosses({{geometryA}}, geometryB)",

    "args": [

        "geometryA - A geometry",

        "geometryB - A geometry"

    ],

    "description": [ 

        "ST_Crosses takes two geometry objects and returns TRUE if their",

        "intersection 'spatially cross', that is, the geometries have some,",

        "but not all interior points in common. The intersection of the interiors",

        "of the geometries must not be the empty set and must have a dimensionality",

        "less than the maximum dimension of the two input geometries.",

        "Additionally, the intersection of the two geometries must not equal either",

        "of the source geometries. Otherwise, it returns FALSE.\n",

        "The following illustrations all return TRUE.\n",

        "<img src=\"@@@.d/st_crosses01.png\">\n",

        "MULTIPOINT/LINESTRING\n",

        "\n",

        "<img src=\"@@@.d/st_crosses02.png\">\n",

        "MULTIPOINT/POLYGON\n",

        "\n",

        "<img src=\"@@@.d/st_crosses03.png\">\n",

        "LINESTRING/POLYGON\n",

        "\n",

        "<img src=\"@@@.d/st_crosses04.png\">\n",

        "LINESTRING/LINESTRING\n"

    ],

    "returnType": "Boolean"

}

{

    "name": "ST_CoveredBy",

    "group": "OGC",

    "template": "ST_CoveredBy({{geometryA}}, geometryB)",

    "args": [

        "geometryA - A geometry",

        "geometryB - A geometry"

    ],

    "description": "Returns TRUE if no point in Geometry A is outside Geometry B",

    "returnType": "Boolean"

}

{

    "name": "ST_Centroid",

    "group": "OGC",

    "template": "ST_Centroid({{geometry}})",

    "args": [

        "geometry - Geometry from which you have to calculate your centroid"

    ],

    "description": "Computes the geometric center of a geometry, or equivalently, the center of mass of the geometry as a POINT",

    "returnType": "Geometry"

}

{

    "name": "ST_ConvexHull",

    "group": "OGC",

    "template": "ST_ConvexHull({{geometry}})",

    "args": [

        "geometry - A geometry"

    ],

    "description": "The convex hull of a geometry represents the minimum convex geometry that encloses all geometries within the set.\nOne can think of the convex hull as the geometry you get by wrapping an elastic band around a set of geometries. This is different from a concave hull which is analogous to shrink-wrapping your geometries.",

    "returnType": "Geometry"

}

{

    "name": "ST_Area",

    "group": "OGC",

    "template": "ST_Area({{geometry}})",

    "args": [

        "geometry - Geometry from which you have to calculate your area"

    ],

    "description": "Returns the area of the geometry if it is a Polygon or MultiPolygon. Return the area measurement of an ST_Surface or ST_MultiSurface value. For geometry, a 2D Cartesian area is determined with units specified by the SRID.",

    "returnType": "Double"

}

{

    "name": "ST_AsText",

    "group": "OGC",

    "template": "ST_AsText({{geometry}})",

    "args": [

        "geometry - Geometry from which you have to calculate your WKT"

    ],

    "description": "Returns the Well-Known Text representation of the geometry.\nWKT format does not maintain precision so to prevent floating truncation, use ST_AsBinary or ST_AsEWKB format for transport.",

    "returnType": "String"

}

{

    "name": "ST_Buffer",

    "group": "OGC",

    "template": "ST_Buffer({{geometry}}, radius)",

    "args": [

        "geometry - Geometry from which you have to calculate your buffer"

        "radius - radius of the buffer"

    ],

    "description": "Returns a geometry that represents all points whose distance from this Geometry is less than or equal to distance.",

    "returnType": "Geometry"

}

{

    "name": "ST_Difference",

    "group": "OGC",

    "template": "ST_Difference({{geometryA}}, geometryB)",

    "args": [

        "geometryA - A geometry",

        "geometryB - A geometry"

    ],

    "description": "Returns a geometry that represents that part of geometry A that does not intersect with geometry B. One can think of this as GeometryA - ST_Intersection(A,B). If A is completely contained in B then an empty geometry collection is returned.",

    "returnType": "Geometry"

}

package org.gvsig.expressionevaluator.impl.function.string;

import org.apache.commons.codec.binary.Base64;

import org.apache.commons.codec.binary.Hex;

import org.apache.commons.lang3.Range;

import org.gvsig.expressionevaluator.Interpreter;

import org.gvsig.expressionevaluator.spi.AbstractFunction;

public class DecodeFunction extends AbstractFunction {

    public DecodeFunction() {

        super(

            "String", "DECODE", Range.is(2),

            "Decode binary data from textual representation in string.\nSupported formats are: base64, hex.",

            "DECODE({{data}}, 'hex')",

            new String[]{

                "data - A string value with the data to be converted",

                "format - A string value indicating the format of the input data. The default value is 'hex'."

            },

            "Byte array",

            true

        );

    }

    @Override

    public Object call(Interpreter interpreter, Object[] args) throws Exception {

        String data_s = getStr(args,0);

        String type = getStr(args,1);

        if( "hex".equalsIgnoreCase(type) ) {

            byte[] data = Hex.decodeHex(data_s.toCharArray());

            return data;

        } else if( "base64".equalsIgnoreCase(type) ) {

            byte[] data = Base64.decodeBase64(data_s);

            return data;

        } else if( "escape".equalsIgnoreCase(type) ) {

            // Not supported

        }

        throw new IllegalArgumentException("Unsupported format type '"+type+"'.");

    }

}

package org.gvsig.expressionevaluator.impl.function.spatial;

import org.apache.commons.lang3.Range;

import org.cresques.cts.IProjection;

import org.gvsig.expressionevaluator.Interpreter;

import org.gvsig.expressionevaluator.impl.ProjectionUtils;

import org.gvsig.expressionevaluator.spi.AbstractFunction;

import org.gvsig.fmap.geom.Geometry;

public class STSRIDFunction extends AbstractFunction {

    public STSRIDFunction() {

        super("OGC", "ST_SRID", Range.is(1));

    }

    @Override

    public Object call(Interpreter interpreter, Object[] args) throws Exception {

        Geometry geom = getGeom(args, 0);

        IProjection proj = geom.getProjection();

        return ProjectionUtils.getCode(proj);

    }

}

import org.cresques.cts.IProjection;

import org.gvsig.fmap.crs.CRSFactory;

        super("OGC", "ST_GeomFromText", Range.between(1,2));

        if( args.length==2 ) {

            int code = getInt(args, 1);

            IProjection proj = CRSFactory.getCRS("EPSG:"+code);

            r.setProjection(proj);

        }

package org.gvsig.expressionevaluator.impl.function.spatial;

import org.apache.commons.lang3.Range;

import org.cresques.cts.IProjection;

import org.gvsig.expressionevaluator.Interpreter;

import org.gvsig.expressionevaluator.spi.AbstractFunction;

import org.gvsig.fmap.crs.CRSFactory;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

public class STGeomFromWKBFunction extends AbstractFunction {

    public STGeomFromWKBFunction() {

        super("OGC", "ST_GeomFromWKB", Range.between(1,2));

    }

    @Override

    public Object call(Interpreter interpreter, Object[] args) throws Exception {

        GeometryManager geomManager = GeometryLocator.getGeometryManager();

        byte[] wkb = (byte[]) getObject(args, 0);

        Geometry r = geomManager.createFrom(wkb);

        if( args.length==2 ) {