Application: gvSIG desktop

import org.apache.commons.lang3.mutable.MutableInt;

import org.gvsig.tools.persistence.xml.XMLPersistenceManager;

//            PersistenceManager persistenceManager = ToolsLocator.getPersistenceManager();

            PersistenceManager persistenceManager = new XMLPersistenceManager();

            PersistentState state = persistenceManager.getState(this, false, new MutableInt(1));

        assertEquals("SELECT(NULL, \"countries\", NULL, TUPLE(), TUPLE(), NULL)", code.toString());

    public void testSelect1() {

        StringBuilder source = new StringBuilder();

        source.append("SELECT * FROM countries");

        Compiler compiler = createCompiler();

        Code code = compiler.compileExpression(source.toString());

        link(code);

        assertEquals("SELECT(NULL, \"countries\", NULL, TUPLE(), TUPLE(), NULL)", code.toString());

    }

        source.append("  FOR row in (SELECT * FROM countries;) "); // Con ;

        assertEquals("BLOCK(LET('X', 0), FOREACH('row', SELECT(NULL, \"countries\", NULL, TUPLE(), TUPLE(), NULL), IFF((\"row\".\"LASTCENSUS\" > 0), LET('X', (\"X\" + \"row\".\"LASTCENSUS\")))))", code.toString());

    public void testSelect3() {

        StringBuilder source = new StringBuilder();

        source.append("BEGIN ");

        source.append("  SET X = 0; ");

        source.append("  FOR row in (SELECT * FROM countries) "); // Sin ;

        source.append("    BEGIN ");

        source.append("      IF row.LASTCENSUS > 0 THEN ");

        source.append("        SET X = X + row.LASTCENSUS ");

        source.append("      END IF ");

        source.append("    END FOR ");

        source.append("END");

        Compiler compiler = createCompiler();

        Code code = compiler.compileExpression(source.toString());

        link(code);

        assertEquals("BLOCK(LET('X', 0), FOREACH('row', SELECT(NULL, \"countries\", NULL, TUPLE(), TUPLE(), NULL), IFF((\"row\".\"LASTCENSUS\" > 0), LET('X', (\"X\" + \"row\".\"LASTCENSUS\")))))", code.toString());

    }

        assertEquals("SELECT(NULL, \"countries\", (\"LASTCENSUS\" > 0), TUPLE(), TUPLE(), NULL)", code.toString());

        assertEquals("SELECT_COUNT(\"countries\", (\"LASTCENSUS\" > 0))", code.toString());

        assertEquals("SELECT(NULL, \"countries\", (\"countries\".\"LASTCENSUS\" > 0), TUPLE(), TUPLE(), NULL)", code.toString());

        assertEquals("SELECT(NULL, \"countries\", NULL, TUPLE(\"CONTINENT\", \"LASTCENSUS\"), TUPLE(TRUE, FALSE), NULL)", code.toString());

        assertEquals("SELECT(NULL, \"countries\", (\"LASTCENSUS\" > 0), TUPLE(\"ID\"), TUPLE(TRUE), NULL)", code.toString());

        assertEquals("SELECT(NULL, \"countries\", (\"LASTCENSUS\" > 0), TUPLE(\"LASTCENSUS\"), TUPLE(FALSE), 3)", code.toString());

        assertEquals("SELECT(NULL, \"countries\", NULL, TUPLE(), TUPLE(), 3)", code.toString());

        assertEquals("EXISTS(SELECT(TUPLE(1), \"countries\", (\"countries\".\"LASTCENSUS\" > 0), TUPLE(), TUPLE(), NULL), 'EXISTS????????????????????????????????')", s);

    public void testExistsSelect2() {

        StringBuilder source = new StringBuilder();

        source.append("EXISTS(");

        source.append(" SELECT 1 FROM countries");

        source.append("   WHERE countries.LASTCENSUS > 0 ");

        source.append(")");

        Compiler compiler = createCompiler();

        Code code = compiler.compileExpression(source.toString());

        link(code);

        String id = "????????????????????????????????";

        String s = code.toString();

        s = s.substring(0, s.length()-id.length()-2)+id+s.substring(s.length()-2);

        assertEquals("EXISTS(SELECT(TUPLE(1), \"countries\", (\"countries\".\"LASTCENSUS\" > 0), TUPLE(), TUPLE(), NULL), 'EXISTS????????????????????????????????')", s);

    }

        assertEquals("EXISTS(SELECT(TUPLE(1), \"countries\", (\"countries\".\"LASTCENSUS\" > 0), TUPLE(), TUPLE(), 1), 'EXISTS????????????????????????????????')", s);

        assertEquals("EXISTS(SELECT(TUPLE(1), \"countries\", ((\"continents\".\"NAME\" = \"countries\".\"CONTINENT\") AND (\"countries\".\"LASTCENSUS\" < 0)), TUPLE(), TUPLE(), 1), 'EXISTS????????????????????????????????')", s);

        source.append("   LIMIT 1 ");

        assertEquals("EXISTS(SELECT(TUPLE(1), \"countries\", ((\"continents\".\"NAME\" = \"countries\".\"CONTINENT\") AND (\"countries\".\"LASTCENSUS\" < 0)), TUPLE(), TUPLE(), 1), 'patata')", code.toString());

        source.append("   TUPLE(1), ");

        source.append("   countries, ");

        source.append("   (countries.LASTCENSUS > 0), ");

        source.append("   TUPLE(), ");

        source.append("   TUPLE(), ");

        source.append("   1 ");

        assertEquals("EXISTS(SELECT(TUPLE(1), \"countries\", (\"countries\".\"LASTCENSUS\" > 0), TUPLE(), TUPLE(), 1), 'EXISTS????????????????????????????????')", s);

package org.gvsig.expressionevaluator.impl;

import java.util.UUID;

import org.gvsig.expressionevaluator.ExpressionBuilder;

import org.gvsig.expressionevaluator.ExpressionBuilder.Value;

import org.gvsig.expressionevaluator.ExpressionUtils;

import static org.gvsig.fmap.dal.DataManager.FUNCTION_CURRENT_ROW;

import static org.gvsig.fmap.dal.DataManager.FUNCTION_CURRENT_STORE;

import static org.gvsig.fmap.dal.DataManager.FUNCTION_EXISTS;

import static org.gvsig.fmap.dal.DataManager.FUNCTION_FOREING_VALUE;

import static org.gvsig.fmap.dal.DataManager.FUNCTION_ISSELECTED_CURRENT_ROW;

import static org.gvsig.fmap.dal.DataManager.FUNCTION_SELECT;

import static org.gvsig.fmap.dal.DataManager.FUNCTION_SELECT_COUNT;

import org.gvsig.fmap.dal.expressionevaluator.DALExpressionBuilder;

/**

 *

 * @author jjdelcerro

 */

public class DefaultDALExpressionBuilder implements DALExpressionBuilder {

  private class DefaultSelectBuilder implements SelectBuilder {

    private Value columns;

    private String tableName;

    private Value where;

    private Long limit;

    private final ExpressionBuilder.Function order;

    private final ExpressionBuilder.Function order_mode;

    public DefaultSelectBuilder() {

      this.columns = expression().tuple(); // ALL === empty tuple

      this.where = null;

      this.order = expression().tuple();

      this.order_mode = expression().tuple();

      this.limit = null;

    }

    @Override

    public SelectBuilder column(String name) {

      ((ExpressionBuilder.Function)columns).parameter(expression().column(name));

      return this;

    }

    @Override

    public SelectBuilder column_all() {

      this.columns = expression().tuple(); // ALL === empty tuple

      return this;

    }

    @Override

    public SelectBuilder table(String tableName) {

      this.tableName = tableName;

      return this;

    }

    @Override

    public SelectBuilder where(ExpressionBuilder.Value where) {

      this.where = where;

      return this;

    }

    @Override

    public SelectBuilder order(String columnName, boolean asc) {

      this.order.parameter(expression().variable(columnName));

      this.order_mode.parameter(expression().constant(asc));

      return this;

    }

    @Override

    public SelectBuilder limit(long limit) {

      this.limit = limit;

      return this;

    }

    @Override

    public ExpressionBuilder.Value toValue() {

      ExpressionBuilder.Function select = expression().function(FUNCTION_SELECT);

      select.parameter(columns);

      select.parameter(expression().variable(tableName));

      select.parameter(where);

      select.parameter(order);

      select.parameter(order_mode);

      select.parameter(expression().constant(limit));

      return select;

    }

    @Override

    public String toString() {

      return this.toValue().toString();

    }

  }

  private class DefaultSelectCountBuilder implements SelectCountBuilder {

    private String tableName;

    private Value where;

    public DefaultSelectCountBuilder() {

    }

    @Override

    public SelectCountBuilder table(String tableName) {

      this.tableName = tableName;

      return this;

    }

    @Override

    public SelectCountBuilder where(ExpressionBuilder.Value where) {

      this.where = where;

      return this;

    }

    @Override

    public ExpressionBuilder.Value toValue() {

      ExpressionBuilder.Function select = expression().function(FUNCTION_SELECT_COUNT);

      select.parameter(expression().variable(tableName));

      if( where != null ) {

        select.parameter(where);

      }

      return select;

    }

    @Override

    public String toString() {

      return this.toValue().toString();

    }

  }

  private ExpressionBuilder expressionBuilder;

  @Override

  public ExpressionBuilder expression() {

    if( this.expressionBuilder == null ) {

      this.expressionBuilder = ExpressionUtils.createExpressionBuilder();

    }

    return this.expressionBuilder;

  }

  @Override

  public SelectBuilder select() {

    return new DefaultSelectBuilder();

  }

  @Override

  public SelectCountBuilder select_count() {

    return new DefaultSelectCountBuilder();

  }

  @Override

  public ExpressionBuilder.Function exists(Value list) {

    return exists(list, null);

  }

  @Override

  public ExpressionBuilder.Function exists(Value list, String exists_id) {

      if( exists_id==null ) {

        exists_id = "EXISTS"+UUID.randomUUID().toString().replaceAll("-", "");

      }

      ExpressionBuilder.Function exists = expression().function(

              FUNCTION_EXISTS,

              list, 

              expression().constant(exists_id)

      );

      return exists;

  }

  @Override

  public ExpressionBuilder.Function foreing_value(String attrlocal, String attrforeing) {

    ExpressionBuilder.Function foreing_value = expression().function(

          FUNCTION_FOREING_VALUE,

          expression().tuple(

                  expression().constant(attrlocal),

                  expression().constant(attrforeing)

          )

    );

    return foreing_value;

  }

  @Override

  public ExpressionBuilder.Function current_row() {

    return expression().function(FUNCTION_CURRENT_ROW);

  }

  @Override

  public ExpressionBuilder.Function current_table() {

    return expression().function(FUNCTION_CURRENT_STORE);

  }

  @Override

  public ExpressionBuilder.Function isselected_current_row() {

    return expression().function(FUNCTION_ISSELECTED_CURRENT_ROW);

  }

}

import org.gvsig.fmap.dal.expressionevaluator.TableAttributeHandler;

  private static final String DAL_SYMBOL_TABLE_FEATURE = "DAL.SymbolTable.Feature";

  private final TableAttributeHandler storeAttributeHandler;

    super(DAL_SYMBOL_TABLE_FEATURE);

    this.storeAttributeHandler = new TableAttributeHandler() {

      @Override

      public Object get(String name) {

        try {

          return feature.get(name);

        } catch (Exception ex) {

          return feature.getExtraValue(name);

      }

      @Override

      public String getName() {

        return storeName;

      }

    };

    if (type.get(name) != null) {

    if (StringUtils.equalsIgnoreCase(name, this.storeName) ||

        StringUtils.equalsIgnoreCase(name, SYMBOL_CURRENT_TABLE) ||

        StringUtils.equalsIgnoreCase(name, SYMBOL_CURRENT_ROW) ) {

    if (feature == null) {

    if (StringUtils.equalsIgnoreCase(name, this.storeName) ||

        StringUtils.equalsIgnoreCase(name, SYMBOL_CURRENT_TABLE)) {

      return this.storeAttributeHandler;

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

      return this.feature;

    }

            true

import java.util.ArrayList;

import org.apache.commons.lang3.StringUtils;

import org.apache.commons.lang3.tuple.ImmutablePair;

import org.apache.commons.lang3.tuple.Pair;

import org.gvsig.expressionevaluator.Code;

import org.gvsig.expressionevaluator.Code.Caller;

import org.gvsig.expressionevaluator.CodeBuilder;

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

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

import org.gvsig.expressionevaluator.Optimizer;

import org.gvsig.expressionevaluator.SymbolTable;

import org.gvsig.fmap.dal.expressionevaluator.ExpressionEvaluator;

import static org.gvsig.fmap.dal.expressionevaluator.FeatureSymbolTable.SYMBOL_CURRENT_TABLE;

import org.gvsig.fmap.dal.expressionevaluator.TableAttributeHandler;

import org.gvsig.fmap.dal.impl.expressionevaluator.DefaultExpressionEvaluator;

import org.gvsig.tools.exception.BaseException;

public class SelectFunction 

        extends AbstractFunction 

        implements Optimizer.FunctionOptimizer

  {

            Range.is(6),

            true

  private static final int COLUMNS = 0;

  private static final int TABLE = 1;

  private static final int WHERE = 2;

  private static final int ORDER = 3;

  private static final int ORDER_MODE = 4;

  private static final int LIMIT = 5;

  private Caller getTupleOrNull(Codes args, int argn) {

    Code code = args.get(argn);

    if( code.code()==Code.CONSTANT ) {

      if( ((Code.Constant)code).value()!=null ) {

        throw new ExpressionRuntimeException("Tupple or null expected in argument "+argn+ " of function '" + FUNCTION_SELECT + "'.");

      }

      return null;

    }

    if( code.code()!=Code.CALLER ) {

      throw new ExpressionRuntimeException("Tupple or null expected in argument "+argn+ " of function '" + FUNCTION_SELECT + "'.");

    }

    Caller caller = (Caller) code;

    if( !StringUtils.equalsIgnoreCase(FUNCTION_TUPLE, caller.name()) ) {

      throw new ExpressionRuntimeException("Tupple or null expected in argument "+argn+ " of function '" + FUNCTION_SELECT + "'.");

    }

    return caller;

  }

    Code.Identifier storeName =  (Code.Identifier) args.get(TABLE);

    Code columns = getTupleOrNull(args, COLUMNS);

    Code where = args.get(WHERE);

    Number limit = (Number) getObject(interpreter, args, LIMIT);

    Caller order = getTupleOrNull(args, ORDER);

    Caller order_mode = getTupleOrNull(args, ORDER_MODE);

    FeatureQueryOrder queryOrder = null;

    if( order!=null || order_mode!=null ) {

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

        String member = (String) interpreter.run(order.parameters().get(n));

        Boolean mode = (Boolean) interpreter.run(order_mode.parameters().get(n));

        if( queryOrder == null ) {

          queryOrder = new FeatureQueryOrder();

        }

        queryOrder.add(member, mode);

    // FIXME: add columns to query.addAttributeName() 

      DataStore store = this.getStore(storeName.name());

      if (where == null && queryOrder == null && limit==null ) {

          removeOuterTablesReferences(interpreter, where);

          ExpressionEvaluator filter = new DefaultExpressionEvaluator(where.toString());

        if (queryOrder != null) {

          query.getOrder().copyFrom(queryOrder);

  private void removeOuterTablesReferences(Interpreter interpreter, Code where) {

    try {

      SymbolTable symbolTable = interpreter.getSymbolTable();

      TableAttributeHandler table = (TableAttributeHandler) symbolTable.value(SYMBOL_CURRENT_TABLE);

      List<Pair<Code,Code>>replaces = new ArrayList<>();

      CodeBuilder codeBuilder = ExpressionUtils.createCodeBuilder();

      where.accept((Object o) -> {

        Code code = (Code) o;

        if( code!=null && code.code() == Code.CALLER ) {

          Code.Caller caller = (Code.Caller) code;

          if( StringUtils.equalsIgnoreCase(caller.name(),FUNCTION_GETATTR) ) {

            Codes args = caller.parameters();

            Code arg0 = args.get(0);

            Code arg1 = args.get(1);

            if( arg0 instanceof Code.Identifier && arg1 instanceof Code.Identifier ) {

              Object tt = symbolTable.value(((Code.Identifier)arg0).name());

              if( tt instanceof TableAttributeHandler && 

                  StringUtils.equalsIgnoreCase(((TableAttributeHandler)tt).getName(), table.getName()) ) {

                String columnName = Objects.toString(((Code.Identifier)arg1).name(), null);

                if( columnName!=null ) {

                  Object value = table.get(columnName);

                  replaces.add(

                          new ImmutablePair<>(

                                  caller,

                                  codeBuilder.constant(value)

                          )

                  );

                }

              }

            }

          }

        }

      });

      for (Pair<Code, Code> replace : replaces) {

        if( replace!=null ) {

          where.replace(replace.getLeft(), replace.getRight());

        }

      }

    } catch (BaseException ex) {

      throw new ExpressionRuntimeException("Can't remove references to outer tables.", ex);

    }

  }

  @Override

  public Code optimize(Optimizer optimizer, Caller caller) {

    return caller; // Don't optimize SELECT

  }

    String storeName =  (String) getObject(interpreter, args, 0);

    String where = Objects.toString(args.get(1),null);

import org.apache.commons.lang3.StringUtils;

import org.gvsig.expressionevaluator.Codes;

import org.gvsig.expressionevaluator.ExpressionSyntaxException;

import org.gvsig.expressionevaluator.Statement.ArgsBuilder;

  private Grammar grammar;

  private static class ExistsStatementBuilder extends DefaultStatement.StatementBuilderBase {

    private final String listID;

    private final String existsID;

    public ExistsStatementBuilder(String listID, String existsID) {

      super(ExistsFunction.NAME, new ArgsBuilderFromNames(listID, existsID));

      this.listID = listID;

      this.existsID = existsID;

    }

    @Override

    public Code build(StatementContext context) {

      CodeBuilder codeBuilder = context.getCodeBuilder();

      Caller code = (Caller) super.build(context);

      BaseCodes args = (BaseCodes) code.parameters();

      if (args.size() < 2) {

        String exists_id = "EXISTS" + UUID.randomUUID().toString().replaceAll("-", "");

        args.add(codeBuilder.constant(exists_id));

      } else if (args.get(1) == null) {

        String exists_id = "EXISTS" + UUID.randomUUID().toString().replaceAll("-", "");

        args.set(1, codeBuilder.constant(exists_id));

      }

      code = codeBuilder.function(ExistsFunction.NAME, args);

      return code;

  }

  private static class SelectArgsBuilder implements ArgsBuilder {

    public SelectArgsBuilder() {

    public String toString() {

      return "select_args()";

    }

    @Override

    public Codes build(StatementContext context) {

      context.trace(this.toString() + ".build");

      CodeBuilder codeBuilder = context.getCodeBuilder();

      BaseCodes args = (BaseCodes) codeBuilder.args();

      Code columns = context.getCode("COLUMNS");

      Code table = context.getCode("TABLE");

      Code where = context.getCode("WHERE");

//      Code order = context.getCode("ORDER");

//      Code order_mode = context.getCode("ORDER_MODE");

      Code limit = context.getCode("LIMIT");

      if (columns == null) {

        throw new ExpressionSyntaxException();

      }

      Caller tuple = codeBuilder.tuple();

      args.add(tuple);

      String s = (String) ((Code.Constant) columns).value();

      if (!StringUtils.equalsIgnoreCase(s, "*")) {

        ((BaseCodes) (tuple.parameters())).add(codeBuilder.constant(1));

      }

      args.add(codeBuilder.identifier((String) ((Code.Constant) table).value()));

      if (where == null) {

        args.add(codeBuilder.constant(null));

      } else {

        args.add(where);

      }

      int n = 1;

      BaseCodes argsX = (BaseCodes) codeBuilder.args();

      while (true) {

        String argNameX = "ORDER" + String.valueOf(n);

        Code code = context.getCode(argNameX);

        if (code == null) {

          break;

        argsX.add(code);

        n++;

      }

      args.add(codeBuilder.tuple(argsX));

      n = 1;

      argsX = (BaseCodes) codeBuilder.args();

      while (true) {

        String argNameX = "ORDER_MODE" + String.valueOf(n);

        Code code = context.getCode(argNameX);

        if (code == null) {

          break;

        }

        argsX.add(code);

        n++;

      }

      args.add(codeBuilder.tuple(argsX));

      if (limit == null) {

        args.add(codeBuilder.constant(null));

      } else {

        args.add(limit);

      }

      return args;

  }

  private static class SelectCountArgsBuilder implements ArgsBuilder {

    public SelectCountArgsBuilder() {

    @Override

    public String toString() {

      return "select_count_args()";

    }

    @Override

    public Codes build(StatementContext context) {

      context.trace(this.toString() + ".build");

      CodeBuilder codeBuilder = context.getCodeBuilder();

      BaseCodes args = (BaseCodes) codeBuilder.args();

      Code table = context.getCode("table");

      Code where = context.getCode("where");

      args.add(codeBuilder.identifier((String) ((Code.Constant) table).value()));

      if (where == null) {

        args.add(codeBuilder.constant(null));

      } else {

        args.add(where);

      }

      return args;

    }

  }

  public DataAccessGrammarFactory() {

    super(DALFunctions.GRAMMAR_NAME, true);

  }

  @Override

  public Grammar create(Object... parameters) {

    ExpressionEvaluatorManager manager = ExpressionEvaluatorLocator.getManager();

    if (this.grammar == null) {

      Grammar theGrammar = manager.createGrammar(this.getName());

      Statement stmt;

      theGrammar.addReservedWord("EXISTS");

      theGrammar.addReservedWord("SELECT");

      theGrammar.addReservedWord("FROM");

      theGrammar.addReservedWord("WHERE");

      theGrammar.addReservedWord("ORDER");

      theGrammar.addReservedWord("DESC");

      theGrammar.addReservedWord("ASC");

      theGrammar.addReservedWord("BY");

      stmt = theGrammar.createStatement("EXISTS");

      stmt.addRule(stmt.require_any_token("EXISTS"));

      stmt.addRule(stmt.require_any_token("("));

      stmt.addRule(stmt.require_expression().capture_as("LIST"));

      stmt.addRule(stmt.optional_any_token(",")

              .addRuleOnTrue(stmt.require_expression().capture_as("ID"))

      );

      stmt.addRule(stmt.require_any_token(")"));

      stmt.builder(new ExistsStatementBuilder("LIST", "ID"));

      theGrammar.addStatement(stmt);

      stmt = theGrammar.createStatement("FOREING_VALUE");

      stmt.addRule(stmt.require_any_token("FOREING"));

      stmt.addRule(stmt.require_any_token("VALUE"));

      stmt.addRule(stmt.require_any_token("FROM"));

      stmt.addRule(stmt.require_identifiers(".").capture_as("IDENTIFIERS"));

      stmt.code(

              FUNCTION_FOREING_VALUE,

              stmt.args_names("IDENTIFIERS")

      );

      theGrammar.addStatement(stmt);

      stmt = theGrammar.createStatement("SELECT");

      stmt.addRule(stmt.require_any_token("SELECT"));

      stmt.addRule(stmt.switch_token()

              .addCase("*", stmt.set_expression("COLUMNS", "*"))

              .addCase("1", stmt.set_expression("COLUMNS", "1"))

              .addDefault(stmt.fail())

      );

      stmt.addRule(stmt.require_any_token("FROM"));

      stmt.addRule(stmt.require_identifier().capture_as("TABLE"));

      stmt.addRule(stmt.optional_any_token("WHERE")

              .addRuleOnTrue(stmt.require_expression().capture_as("WHERE"))

      );

      stmt.addRule(stmt.optional_any_token("ORDER")

              .addRuleOnTrue(stmt.require_any_token("BY"))

              .addRuleOnTrue(stmt.repeat()

                      .addRule(stmt.require_expression().capture_as("ORDER#"))

                      .addRule(stmt.switch_token()

                              .addCase("ASC", stmt.set_expression("ORDER_MODE#", true))

                              .addCase("DESC", stmt.set_expression("ORDER_MODE#", false))

                              .addDefault(stmt.set_expression("ORDER_MODE#", true))

                      )

                      .addRule(stmt.optional_any_token(",")

                              .addRuleOnFalse(stmt.break_loop())

                      )

              )

      );

      stmt.addRule(stmt.optional_any_token("LIMIT")

              .addRuleOnTrue(stmt.require_expression().capture_as("LIMIT"))

      );

      stmt.addRule(stmt.optional_any_token(";"));

      stmt.code(

              FUNCTION_SELECT,

              new SelectArgsBuilder()

      );

      theGrammar.addStatement(stmt);

      stmt = theGrammar.createStatement("SELECT_COUNT");

      stmt.addRule(stmt.require_any_token("SELECT"));

      stmt.addRule(stmt.require_any_token("COUNT"));

      stmt.addRule(stmt.require_any_token("("));

      stmt.addRule(stmt.require_any_token("*"));

      stmt.addRule(stmt.require_any_token(")"));

      stmt.addRule(stmt.require_any_token("FROM"));

      stmt.addRule(stmt.require_identifier().capture_as("TABLE"));

      stmt.addRule(stmt.optional_any_token("WHERE")

              .addRuleOnTrue(stmt.require_expression().capture_as("WHERE"))

      );

      stmt.addRule(stmt.require_any_token(";"));

      stmt.code(

              FUNCTION_SELECT_COUNT,

              new SelectCountArgsBuilder()

      );

      theGrammar.addStatement(stmt);

      this.grammar = theGrammar;

    }

    return grammar;

  }

  public static final void selfRegister() {

    ExpressionEvaluatorManager manager = ExpressionEvaluatorLocator.getManager();

    manager.registerGrammar(new DataAccessGrammarFactory());

  }

        this.featureSymbolTable = new FeatureSymbolTableImpl();

        this.expression = expression;

import org.gvsig.expressionevaluator.impl.symboltable.FeatureSymbolTableImpl;

        if (this.symbolTable == null || this.featureSymbolTable==null ) {

            this.featureSymbolTable = new FeatureSymbolTableImpl();

import java.util.Map;

import org.apache.commons.collections4.map.LRUMap;

import org.gvsig.tools.util.CachedValue;

    private class CachedConfigValue extends CachedValue<String> {

        private final String name;

        public CachedConfigValue(String name, String value) {

          this.setValue(value);

          this.name = name;

        public CachedConfigValue(String name, String value, long expireTime) {

          this.name = name;

          this.setValue(value);

          this.setExpireTime(expireTime);

            String s = DefaultDatabaseWorkspaceManager.this.getConfigValue(name);

                this.setValue(null);

                this.setValue(s);

    private CachedValue<File> baseFolder;

    private Map<String,CachedConfigValue> cachedConfigValues;

        this.baseFolder = new CachedValue() {

          @Override

          protected void reload() {

            String s = DefaultDatabaseWorkspaceManager.this.getConfigValue(CONFIG_NAME_BASEFOLDER);

            if( StringUtils.isBlank(s) ) {

                this.setValue(null);

            } else {

                this.setValue(new File(s));

            }

          }

        };

        this.baseFolder.setExpireTime(20000); // 20seg

        this.cachedConfigValues = new LRUMap<>(20, 20);

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

              return this.baseFolder.get().toString();

            }

            CachedConfigValue cachedValue = this.cachedConfigValues.get(name);

            if( cachedValue != null ) {

              return cachedValue.get();

            }

            String value = this.getConfigValue(name);

            this.cachedConfigValues.put(name, new CachedConfigValue(name, value, 15000));

            return value;

        } catch (Exception ex) {

            LOGGER.warn("Can't read configuration value '"+name+"'", ex);

            return null;

        }

    }

    private String getConfigValue(String name) {

        try {

            if( !this.existsConfiguration() ) {

                return null;

            }

            if( this.cachedConfigValues.containsKey(name) ) {

              this.cachedConfigValues.get(name).set(value);

            }

        this.set(CONFIG_NAME_BASEFOLDER, baseFolder.toString());

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

                return true;

              }

              if( this.cachedConfigValues.containsKey(name) ) {

                return true;

              }

              FeatureStore store = this.getTable(TABLE_CONFIGURATION);

              if (store != null) {

                  ExpressionBuilder builder = ExpressionUtils.createExpressionBuilder();

                  String filter = builder.eq(

                          builder.column(FIELD_CONFIGURATION_NAME),

                          builder.constant(name)

                  ).toString();

                  Feature feature = store.findFirst(filter);

                  if (feature != null) {

                      String value = feature.getString(FIELD_CONFIGURATION_VALUE);

                      value = ExpressionUtils.evaluateDynamicText(this, value);

                      this.cachedConfigValues.put(name, new CachedConfigValue(name, value, 15000));

                      return true;

                  }