Application: gvSIG desktop

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2020 gvSIG Association.

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 3

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 * For any additional information, do not hesitate to contact us

 * at info AT gvsig.com, or visit our website www.gvsig.com.

 */

package org.gvsig.expressionevaluator.impl.grammars;

import java.util.UUID;

import org.gvsig.expressionevaluator.Code;

import org.gvsig.expressionevaluator.CodeBuilder;

import org.gvsig.expressionevaluator.Codes;

import org.gvsig.expressionevaluator.ExpressionEvaluatorLocator;

import org.gvsig.expressionevaluator.ExpressionEvaluatorManager;

import org.gvsig.expressionevaluator.Grammar;

import org.gvsig.expressionevaluator.Statement;

import org.gvsig.expressionevaluator.Statement.ArgsBuilder;

import org.gvsig.expressionevaluator.Statement.StatementContext;

import org.gvsig.expressionevaluator.impl.DALFunctions;

import org.gvsig.expressionevaluator.impl.DefaultCodeBuilder.BaseCodes;

import org.gvsig.expressionevaluator.impl.DefaultStatement;

import org.gvsig.expressionevaluator.impl.DefaultStatement.ArgsBuilderFromNames;

import org.gvsig.expressionevaluator.impl.function.dataaccess.ExistsFunction;

import org.gvsig.expressionevaluator.spi.AbstractGrammarFactory;

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

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

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

import org.gvsig.expressionevaluator.Code.Callable;

import static org.gvsig.expressionevaluator.impl.function.dataaccess.SelectAggregateFunction.FUNCTION_SELECT_AGGREGATE;

import static org.gvsig.expressionevaluator.impl.function.dataaccess.SelectFunction.MODE_FROM_SELECTION;

import static org.gvsig.expressionevaluator.impl.function.dataaccess.SelectFunction.MODE_FROM_SELECTION_IF_NOT_EMPTY;

import static org.gvsig.expressionevaluator.impl.function.dataaccess.SelectFunction.MODE_FROM_STORE;

import org.gvsig.fmap.dal.DataManager;

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

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

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

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

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

/**

 *

 * @author jjdelcerro

 */

public class DataAccessGrammarFactory extends AbstractGrammarFactory {

    //?Ojo!, esto est? copiado de DefaultExpression por cuestiones de dependencias. Si lo tocamos hay que tocarlo en los dos lados

    public static final String COMPATIBILITY_SELECT_ID = "SELECT";

    public static final String COMPATIBILITY_SELECT_OPTIONAL_SEMICOLON_AT_END = "OPTIONAL_SEMICOLON_AT_END";

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

            Callable code = (Callable) 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() {

        }

        @Override

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

            return build(context, args);

        }

        public Codes build(StatementContext context, BaseCodes args) {

            int n;

            BaseCodes argsX;

            CodeBuilder codeBuilder = context.getCodeBuilder();

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

            args.add(columns);

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

            args.add(table);

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

            if (where == null) {

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

            } else {

                args.add(where);

            }

            n = 1;

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

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

            if (limit == null) {

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

            } else {

                args.add(limit);

            }

            Code intovar = context.getCode("INTOVAR");

            if (intovar != null) {

                args.add(intovar);

            }

            int mode = MODE_FROM_STORE;

            Code selection = context.getCode("SELECTION");

            Code if_not_empty = context.getCode("IF_NOT_EMPTY");

            if (selection != null) {

                if( if_not_empty == null ) {

                    mode = MODE_FROM_SELECTION;

                } else {

                    mode = MODE_FROM_SELECTION_IF_NOT_EMPTY;

                }

            }

            if( mode != MODE_FROM_STORE ) {

                if( intovar == null ) {

                    args.add(intovar);

                }

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

            }

            return args;            

        }

    }

    private static class InsertIntoArgsBuilder

            extends SelectArgsBuilder

            implements ArgsBuilder {

        public InsertIntoArgsBuilder() {

        }

        @Override

        public String toString() {

            return "insert_into_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("TARGETTABLE");

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

            return build(context, 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(table);

            if (where == null) {

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

            } else {

                args.add(where);

            }

            return args;

        }

    }

    private static class SelectAggregateArgsBuilder implements ArgsBuilder {

        public SelectAggregateArgsBuilder() {

        }

        @Override

        public String toString() {

            return "select_aggregate_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");

            Code aggregateFunction = context.getCode("AGGREGATE_FUNCTION");

            Code aggregateColumn = context.getCode("AGGREGATE_COLUMN");

            args.add(table);

            if (where == null) {

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

            } else {

                args.add(where);

            }

            args.add(aggregateFunction);

            args.add(aggregateColumn);

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

            theGrammar.addStatement(createCreateInMemoryTableStatement(theGrammar));

            theGrammar.addStatement(createCreateTableStatement(theGrammar));

            theGrammar.addStatement(createCreateTableStructureStatement(theGrammar));

            theGrammar.addStatement(createExistsStatement(theGrammar));

            theGrammar.addStatement(createForeingValueStatement(theGrammar));

            theGrammar.addStatement(createInsertIntoTableSelectStatement(theGrammar));

            theGrammar.addStatement(createSelectCountStatement(theGrammar));

            theGrammar.addStatement(createSelectAggregateStatement(theGrammar));

            theGrammar.addStatement(createSelectStatement(theGrammar));

//            theGrammar.addStatement(createSelectIntoStatement(theGrammar));

//            theGrammar.addStatement(createUpdateStatement(theGrammar));

            theGrammar.addStatement(createSelectCountFromSelectionStatement(theGrammar));

//            theGrammar.addStatement(createSelectFromSelectionStatement(theGrammar));

            this.grammar = theGrammar;

        }

        return grammar;

    }

    private Statement createExistsStatement(Grammar theGrammar) {

//    

//      EXISTS( SELECT...)

//

        Statement stmt;

        theGrammar.addReservedWord("EXISTS");

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

        return stmt;

    }

    private Statement createForeingValueStatement(Grammar theGrammar) {

        Statement stmt;

//      

//      FOREING VALUE FROM table_name.column_name  

//        

        theGrammar.addReservedWord("FROM");

        stmt = theGrammar.createStatement(FUNCTION_FOREIGN_VALUE);

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

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

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

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

        stmt.code(

                FUNCTION_FOREIGN_VALUE,

                stmt.args_names("IDENTIFIERS")

        );

        return stmt;

    }

    private Statement createCreateInMemoryTableStatement(Grammar theGrammar) {

        Statement stmt;

//

//      CREATE IN MEMORY TABLE target_table_name FROM source_table_name

//        

        theGrammar.addReservedWord("FROM");

        stmt = theGrammar.createStatement("CREATE_IN_MEMORY_TABLE");

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

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

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

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

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

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

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

        stmt.code(

                FUNCTION_FOREING_VALUE,

                stmt.args_names("NEWTABLE", "SOURCETABLE")

        );

        return stmt;

    }

    private Statement createSelectStatement(Grammar theGrammar) {

        Statement stmt;

//

//      SELECT * | (column1, column2,...) 

//          FROM table_name

//          WHERE expression

//          ORDER BY expression1 ASC|DESC, expression2 ASC|DESC ...

//          LIMIT expression

//        

        theGrammar.addReservedWord("SELECT");

        theGrammar.addReservedWord("FROM");

        theGrammar.addReservedWord("WHERE");

        theGrammar.addReservedWord("ORDER");

        theGrammar.addReservedWord("BY");

        theGrammar.addReservedWord("DESC");

        theGrammar.addReservedWord("ASC");

        theGrammar.addReservedWord("LIMIT");

        ExpressionEvaluatorManager manager = ExpressionEvaluatorLocator.getManager();

        CodeBuilder codeBuilder = manager.createCodeBuilder();

        stmt = theGrammar.createStatement("SELECT");

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

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

                .addRuleOnTrue(stmt.set_expression("COLUMNS", codeBuilder.tuple()))

                .addRuleOnTrue(stmt.optional_any_token("INTO")

                    .addRuleOnTrue(stmt.require_identifier().capture_as("INTOVAR"))

                )                

                .addRuleOnFalse(stmt.require_expressions(",").capture_as("COLUMNS"))

        );

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

        stmt.addRule(stmt.optional_any_token("SELECTION").capture_as("SELECTION")

                .addRuleOnTrue(stmt.optional_any_token("IF")

                    .addRuleOnTrue(stmt.require_tokens("NOT", "EMPTY").capture_as("IF_NOT_EMPTY"))

                )

                .addRuleOnTrue(stmt.optional_any_token("OF"))

        );

        stmt.addRule(stmt.require_expression().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.if_compatibility_contains(

                COMPATIBILITY_SELECT_ID,

                COMPATIBILITY_SELECT_OPTIONAL_SEMICOLON_AT_END

            )

            .addRuleOnTrue(stmt.optional_any_token(";"))

        );

        stmt.code(

                FUNCTION_SELECT,

                new SelectArgsBuilder()

        );

        return stmt;

    }

    private Statement createSelectIntoStatement(Grammar theGrammar) {

        Statement stmt;

//

//      SELECT * INTO varname

//          FROM table_name

//          WHERE expression

//          ORDER BY expression1 ASC|DESC, expression2 ASC|DESC ...

//          LIMIT expression

//        

        theGrammar.addReservedWord("SELECT");

        theGrammar.addReservedWord("FROM");

        theGrammar.addReservedWord("WHERE");

        theGrammar.addReservedWord("ORDER");

        theGrammar.addReservedWord("BY");

        theGrammar.addReservedWord("DESC");

        theGrammar.addReservedWord("ASC");

        theGrammar.addReservedWord("LIMIT");

        stmt = theGrammar.createStatement("SELECT");

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

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

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

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

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

        stmt.addRule(stmt.require_expression().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.code(

                FUNCTION_SELECT,

                new SelectArgsBuilder()

        );

        return stmt;

    }

    private Statement createSelectFromSelectionStatement(Grammar theGrammar) {

        Statement stmt;

//

//      SELECT * | (column1, column2,...) 

//          FROM SELECTION OF table_name

//          WHERE expression

//        

        ExpressionEvaluatorManager manager = ExpressionEvaluatorLocator.getManager();

        CodeBuilder codeBuilder = manager.createCodeBuilder();

        stmt = theGrammar.createStatement("SELECTFROMSELECTION");

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

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

                .addRuleOnTrue(stmt.set_expression("COLUMNS", codeBuilder.tuple()))

                .addRuleOnFalse(stmt.require_identifiers(",").capture_as("COLUMNS"))

        );

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

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

        stmt.addRule(stmt.optional_any_token("IF")

                .addRuleOnTrue(stmt.require_tokens("NOT", "EMPTY").capture_as("IF_NOT_EMPTY"))

        );

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

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

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

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

        );

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

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

        );

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

        stmt.code(

                FUNCTION_SELECT_FROM_SELECTION,

                stmt.args_names("COLUMNS", "TABLE", "WHERE", "LIMIT","IF_NOT_EMPTY")

        );

        return stmt;

    }

    private Statement createInsertIntoTableSelectStatement(Grammar theGrammar) {

        Statement stmt;

//

//      INSERT INTO target_table_name 

//          SELECT

//              FROM table_name

//              WHERE expression

//              ORDER BY expression1 ASC|DESC, expression2 ASC|DESC ...

//              LIMIT expression

//        

//        

        theGrammar.addReservedWord("INSERT");

        theGrammar.addReservedWord("INTO");

        theGrammar.addReservedWord("SELECT");

        theGrammar.addReservedWord("FROM");

        theGrammar.addReservedWord("WHERE");

        theGrammar.addReservedWord("ORDER");

        theGrammar.addReservedWord("BY");

        theGrammar.addReservedWord("LIMIT");

        ExpressionEvaluatorManager manager = ExpressionEvaluatorLocator.getManager();

        CodeBuilder codeBuilder = manager.createCodeBuilder();

        stmt = theGrammar.createStatement("INSERT_INTO_SELECT");

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

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

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

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

        stmt.addRule(stmt.optional_any_token("*")

                .addRuleOnTrue(stmt.set_expression("COLUMNS", codeBuilder.tuple()))

                .addRuleOnFalse(stmt.require_identifiers(",").capture_as("COLUMNS"))

        );

        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(

                DataManager.FUNCTION_INSERT_INTO_TABLE,

                new InsertIntoArgsBuilder()

        );

        return stmt;

    }

    private Statement createSelectCountStatement(Grammar theGrammar) {

        Statement stmt;

//

//      SELECT COUNT(*) FROM table_name WHERE expression

//        

        theGrammar.addReservedWord("SELECT");

        theGrammar.addReservedWord("FROM");

        theGrammar.addReservedWord("WHERE");

        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_expression().capture_as("TABLE"));

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

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

        );

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

        stmt.code(

                FUNCTION_SELECT_COUNT,

                new SelectCountArgsBuilder()

        );

        return stmt;

    }

    private Statement createSelectAggregateStatement(Grammar theGrammar) {

        Statement stmt;

//

//      SELECT COUNT(*) FROM table_name WHERE expression

//        

        theGrammar.addReservedWord("SELECT");

        theGrammar.addReservedWord("FROM");

        theGrammar.addReservedWord("WHERE");

        stmt = theGrammar.createStatement("SELECT_COUNT");

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

        stmt.addRule(stmt.require_any_token("COUNT","SUM", "MIN","MAX", "AVG").capture_as("AGGREGATE_FUNCTION"));

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

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

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

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

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

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

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

        );

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

        stmt.code(

                FUNCTION_SELECT_AGGREGATE,

                new SelectAggregateArgsBuilder()

        );

        return stmt;

    }

    private Statement createSelectCountFromSelectionStatement(Grammar theGrammar) {

        Statement stmt;

//

//      SELECT COUNT(*) FROM SELECTION IF NOT IS EMPTY OF table_name WHERE expression

//        

        stmt = theGrammar.createStatement("SELECT_COUNT_FROM_SELECTION");

        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_any_token("SELECTION"));

        stmt.addRule(stmt.optional_any_token("IF")

                .addRuleOnTrue(stmt.require_tokens("NOT", "EMPTY").capture_as("IF_NOT_EMPTY"))

        );

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

        stmt.addRule(stmt.require_expression().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_FROM_SELECTION,

                stmt.args_names("TABLE", "WHERE", "IF_NOT_EMPTY")

        );

        return stmt;

    }

    private Statement createCreateTableStatement(Grammar theGrammar) {

        Statement stmt;

//

//      CREATE TABLE 

//              ...json_definition...

//          IN

//             ...target_table_parameters_as_json

//        

        theGrammar.addReservedWord("CREATE");

        stmt = theGrammar.createStatement("CREATE_TABLE");

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

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

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

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

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

        stmt.code(

                FUNCTION_CREATE_TABLE,

                stmt.args_names("STRUCTURE", "LOCATION")

        );

        return stmt;

    }

    private Statement createCreateTableStructureStatement(Grammar theGrammar) {

        Statement stmt;

//

//      CREATE TABLE STRUCTURE

//              ...json_definition...

//        

        theGrammar.addReservedWord("CREATE");

        stmt = theGrammar.createStatement("CREATE_TABLE_STRUCTURE");

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

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

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

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

        stmt.code(

                FUNCTION_CREATE_TABLE_STRUCTURE,

                stmt.args_names("STRUCTURE")

        );

        return stmt;

    }

    private Statement createInsertIntoTableStatement(Grammar theGrammar) {

        // TODO: terminar de implementar

        Statement stmt;

//

//      INSERT INTO table_name 

//              ( column_name1, column_name2,... )

//          VALUES

//              ( expression1, expression2, ...) | expression_list

//

        theGrammar.addReservedWord("INSERT");

        theGrammar.addReservedWord("INTO");

//        theGrammar.addReservedWord("VALUES");

        stmt = theGrammar.createStatement("INSERT_INTO");

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

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

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

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

        stmt.addRule(stmt.require_identifiers(",").capture_as("COLUMNS"));

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

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

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

                .addRuleOnTrue(stmt.require_expressions(",").capture_as("VALUES"))

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

                .addRuleOnFalse(stmt.require_expression().capture_as("VALUES"))

        );

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

//        stmt.code(

//                DataManager.FUNCTION_INSERT_INTO,

//                stmt.args_names("TARGETTABLE","COLUMNS", "VALUES")

//        );

        return stmt;

    }

    private Statement createUpdateStatement(Grammar theGrammar) {

        Statement stmt;

//        

//      UPDATE table_name

//        SET column1 = expression1, column2 = expression2, ...

//        WHERE condition; 

//

        theGrammar.addReservedWord("UPDATE");

        theGrammar.addReservedWord("WHERE");

        stmt = theGrammar.createStatement("UPDATE");

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

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

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

        stmt.addRule(stmt.repeat_until_any_tokens("WHERE")

                .addRule(stmt.require_identifier().capture_as("#COLUMNS"))

                .addRule(stmt.require_any_token("="))

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

        );

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

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

        stmt.code(

                DataManager.FUNCTION_UPDATE,

                stmt.args_names("TABLE","CONDITION","#COLUMNS", "#VALUES")

        );

        return stmt;

    }

    private Statement createDeleteFromTableStatement(Grammar theGrammar) {

        // TODO: terminar de implementar

        Statement stmt;

//

//      DELETE FROM table_name WHERE condition;

//

        theGrammar.addReservedWord("DELETE");

        theGrammar.addReservedWord("WHERE");

        stmt = theGrammar.createStatement("DELETE");

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

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

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

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

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

//        stmt.code(

//                DataManager.FUNCTION_DELETE,

//                stmt.args_names("TABLE","CONDITION")

//        );

        return stmt;

    }

    public static final void selfRegister() {

        ExpressionEvaluatorManager manager = ExpressionEvaluatorLocator.getManager();

        manager.registerGrammar(new DataAccessGrammarFactory());

    }

}