Application: gvSIG desktop

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

  }