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.Code.Caller;

import org.gvsig.expressionevaluator.CodeBuilder;

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

/**

 *

 * @author jjdelcerro

 */

public class DataAccessGrammarFactory extends AbstractGrammarFactory {

    private Grammar grammar;

    private class ExistsStatementBuilder extends DefaultStatement.StatementBuilderBase {

        private final String ListID;

        public ExistsStatementBuilder(String ListID) {

            super(ExistsFunction.NAME, new ArgsBuilderFromNames(ListID));

            this.ListID = ListID;

        }

        @Override

        public Code build(StatementContext context) {

            UUID x = UUID.randomUUID();

            String exists_id = x.toString().replaceAll("-", "");

            CodeBuilder codeBuilder = context.getCodeBuilder();

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

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

            args.add("EXISTS_ID", codeBuilder.constant(exists_id));

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

            return code;

        }

    }

    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_expression("LIST"));

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

            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("IDENTIFIERS","."));

            stmt.code(

                    DALFunctions.FUNCTION_FOREING_VALUE,

                    stmt.args_names("IDENTIFIERS")

            ); 

            theGrammar.addStatement(stmt);

            stmt = theGrammar.createStatement("SELECT");

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

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

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

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

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

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

            );

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

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

                    .addRuleOnTrue(

                      stmt.repeat()

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

            );

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

            stmt.code(

                    DALFunctions.FUNCTION_SELECT,

                    stmt.args_names("TABLE","WHERE","ORDER#","ORDER_MODE#","LIMIT")

            ); 

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

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

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

            );

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

            stmt.code(

                    DALFunctions.FUNCTION_SELECT_COUNT,

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

            ); 

            theGrammar.addStatement(stmt);

            this.grammar = theGrammar;

        }

        return grammar;

    }

    public static final void selfRegister() {

        ExpressionEvaluatorManager manager = ExpressionEvaluatorLocator.getManager();

        manager.registerGrammar(new DataAccessGrammarFactory());

    }

}