* ModeShape (http://www.modeshape.org)

*

* Licensed under the Apache License, Version 2.0 (the "License");

* you may not use this file except in compliance with the License.

* You may obtain a copy of the License at

*

*       http://www.apache.org/licenses/LICENSE-2.0

*

* Unless required by applicable law or agreed to in writing, software

* distributed under the License is distributed on an "AS IS" BASIS,

* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

* See the License for the specific language governing permissions and

* limitations under the License.

*/

* Oracle-specific DDL Parser. Includes custom data types as well as custom DDL statements.

*/

    implements OracleDdlConstants, OracleDdlConstants.OracleStatementStartPhrases {

    /**

     * The Oracle parser identifier.

     */

    public static final String ID = "ORACLE";

    static List<String[]> oracleDataTypeStrings = new ArrayList<String[]>();

    public OracleDdlParser() {

        super();

        setDatatypeParser(new OracleDataTypeParser());

        initialize();

    }

    /**

     * {@inheritDoc}

     *

     * @see org.modeshape.sequencer.ddl.StandardDdlParser#areNextTokensCreateTableOptions(org.modeshape.sequencer.ddl.DdlTokenStream)

     */

    @Override

    protected boolean areNextTokensCreateTableOptions( final DdlTokenStream tokens ) throws ParsingException {

        // current token can't be a terminator or the next n-tokens can't be a statement

        return (tokens.hasNext() && !isTerminator(tokens) && (tokens.computeNextStatementStartKeywordCount() == 0));

    }

    /**

     * {@inheritDoc}

     *

     * @see org.modeshape.sequencer.ddl.StandardDdlParser#parseNextCreateTableOption(org.modeshape.sequencer.ddl.DdlTokenStream,

     *      org.modeshape.sequencer.ddl.node.AstNode)

     */

    @Override

    protected void parseNextCreateTableOption( final DdlTokenStream tokens,

                                               final AstNode tableNode ) throws ParsingException {

        final String tableProperty = tokens.consume();

        boolean processed = false;

        // if token is a number add it to previous option

        if (tableProperty.matches("\\b\\d+\\b")) {

            final List<AstNode> options = tableNode.getChildren(TYPE_STATEMENT_OPTION);

            if (!options.isEmpty()) {

                final AstNode option = options.get(options.size() - 1);

                final String currValue = (String)option.getProperty(VALUE);

                option.setProperty(VALUE, currValue + SPACE + tableProperty);

                processed = true;

            }

        }

        if (!processed) {

            final AstNode tableOption = nodeFactory().node("option", tableNode, TYPE_STATEMENT_OPTION);

            tableOption.setProperty(VALUE, tableProperty);

        }

    }

    private void initialize() {

        setTerminator(DEFAULT_TERMINATOR);

        setDoUseTerminator(true);

        oracleDataTypeStrings.addAll(OracleDataTypes.CUSTOM_DATATYPE_START_PHRASES); //

    }

    /**

     * {@inheritDoc}

     *

     * @see org.modeshape.sequencer.ddl.StandardDdlParser#getId()

     */

    @Override

    public String getId() {

        return ID;

    }

    /**

     * {@inheritDoc}

     *

     * @see org.modeshape.sequencer.ddl.StandardDdlParser#getIdentifyingKeywords()

     */

    @Override

    public String[] getIdentifyingKeywords() {

        return new String[] {getId(), "spool.log"};

    }

    /**

     * {@inheritDoc}

     *

     * @see org.modeshape.sequencer.ddl.StandardDdlParser#initializeTokenStream(org.modeshape.sequencer.ddl.DdlTokenStream)

     */

    @Override

    protected void initializeTokenStream( DdlTokenStream tokens ) {

        super.initializeTokenStream(tokens);

        tokens.registerKeyWords(CUSTOM_KEYWORDS);

        tokens.registerKeyWords(OracleDataTypes.CUSTOM_DATATYPE_START_WORDS);

        tokens.registerStatementStartPhrase(ALTER_PHRASES);

        tokens.registerStatementStartPhrase(CREATE_PHRASES);

        tokens.registerStatementStartPhrase(DROP_PHRASES);

        tokens.registerStatementStartPhrase(MISC_PHRASES);

        tokens.registerStatementStartPhrase(SET_PHRASES);

    }

    @Override

    protected void rewrite( DdlTokenStream tokens,

                            AstNode rootNode ) {

        assert tokens != null;

        assert rootNode != null;

        // We may have a prepare statement that is followed by a missing terminator node

        // We also may have nodes that have an extra terminator node representing the '/' backslash

        // These nodes will have type "TYPE_BACKSLASH_TERMINATOR".

        List<AstNode> copyOfNodes = new ArrayList<AstNode>(rootNode.getChildren());

        AstNode complexNode = null;

        for (AstNode child : copyOfNodes) {

            if ((complexNode != null && nodeFactory().hasMixinType(child, TYPE_UNKNOWN_STATEMENT))

                || (complexNode != null && nodeFactory().hasMixinType(child, TYPE_BACKSLASH_TERMINATOR))) {

                mergeNodes(tokens, complexNode, child);

                rootNode.removeChild(child);

            } else {

                complexNode = null;

            }

            if (nodeFactory().hasMixinType(child, TYPE_CREATE_FUNCTION_STATEMENT)

                || nodeFactory().hasMixinType(child, TYPE_CREATE_TRIGGER_STATEMENT)

                || nodeFactory().hasMixinType(child, TYPE_CREATE_LIBRARY_STATEMENT)

                || nodeFactory().hasMixinType(child, TYPE_CREATE_PACKAGE_STATEMENT)

                || nodeFactory().hasMixinType(child, TYPE_CREATE_PROCEDURE_STATEMENT)) {

                complexNode = child;

            }

        }

        // We also may have nodes that have an extra terminator node representing the '/' backslash

        // These nodes will have type "TYPE_BACKSLASH_TERMINATOR".

        super.rewrite(tokens, rootNode); // Removes all extra "missing terminator" nodes

        // Now we need to walk the tree again looking for unknown nodes under the root

        // and attach them to the previous node, assuming the node can contain multiple nested statements.

        // CREATE FUNCTION is one of those types

        copyOfNodes = new ArrayList<AstNode>(rootNode.getChildren());

        boolean foundComplexNode = false;

        complexNode = null;

        for (AstNode child : copyOfNodes) {

            if (matchesComplexNode(child)) {

                foundComplexNode = true;

                complexNode = child;

            } else if (foundComplexNode) {

                if (complexNode != null && nodeFactory().hasMixinType(child, TYPE_UNKNOWN_STATEMENT)) {

                    mergeNodes(tokens, complexNode, child);

                    rootNode.removeChild(child);

                } else {

                    foundComplexNode = false;

                    complexNode = null;

                }

            }

        }

    }

    /**

     * {@inheritDoc}

     *

     * @see org.modeshape.sequencer.ddl.StandardDdlParser#consumeIdentifier(org.modeshape.sequencer.ddl.DdlTokenStream)

     */

    @Override

    protected String consumeIdentifier( DdlTokenStream tokens ) throws ParsingException {

        Position startPosition = tokens.nextPosition();

        String id = super.consumeIdentifier(tokens);

        Position nextPosition = tokens.nextPosition();

        while (((nextPosition.getIndexInContent() - startPosition.getIndexInContent() - id.length()) == 0)) {

            // allowed symbols in an identifier: underscore, dollar sign, pound sign, at sign

            if (tokens.matches(DdlTokenizer.SYMBOL)) {

                if (tokens.matches('$') || tokens.matches('#') || tokens.matches('@')) {

                    id += tokens.consume(); // consume symbol

                } else {

                    break; // not a valid ID symbol

                }

            } else {

                id += tokens.consume(); // consume text

            }

            nextPosition = tokens.nextPosition();

        }

        return id;

    }

    private boolean matchesComplexNode( AstNode node ) {

        assert node != null;

        for (String mixin : COMPLEX_STMT_TYPES) {

            if (nodeFactory().hasMixinType(node, mixin)) {

                return true;

            }

        }

        return false;

    }

    /**

     * {@inheritDoc}

     *

     * @see org.modeshape.sequencer.ddl.StandardDdlParser#handleUnknownToken(org.modeshape.sequencer.ddl.DdlTokenStream,

     *      java.lang.String)

     */

    @Override

    public AstNode handleUnknownToken( DdlTokenStream tokens,

                                       String tokenValue ) throws ParsingException {

        if (tokenValue.equals("/")) {

            return nodeFactory().node("backslashTerminator", getRootNode(), TYPE_BACKSLASH_TERMINATOR);

        }

        return null;

    }

    /**

     * {@inheritDoc} The CREATE SCHEMA statement can include CREATE TABLE, CREATE VIEW, and GRANT statements.

     *

     * @see org.modeshape.sequencer.ddl.StandardDdlParser#parseCreateSchemaStatement(org.modeshape.sequencer.ddl.DdlTokenStream,

     *      org.modeshape.sequencer.ddl.node.AstNode)

     */

    @Override

    protected AstNode parseCreateSchemaStatement( DdlTokenStream tokens,

                                                  AstNode parentNode ) throws ParsingException {

        assert tokens != null;

        assert parentNode != null;

        return super.parseCreateSchemaStatement(tokens, parentNode);

    }

    /**

     * {@inheritDoc}

     *

     * @see org.modeshape.sequencer.ddl.StandardDdlParser#parseCustomStatement(org.modeshape.sequencer.ddl.DdlTokenStream,

     *      org.modeshape.sequencer.ddl.node.AstNode)

     */

    @Override

    protected AstNode parseCustomStatement( DdlTokenStream tokens,

                                            AstNode parentNode ) throws ParsingException {

        assert tokens != null;

        assert parentNode != null;

        AstNode result = null;

        if (tokens.matches(STMT_COMMENT_ON)) {

            result = parseCommentStatement(tokens, parentNode);

        } else if (tokens.matches(STMT_ANALYZE)) {

            return parseStatement(tokens, STMT_ANALYZE, parentNode, TYPE_ANALYZE_STATEMENT);

        } else if (tokens.matches(STMT_ASSOCIATE_STATISTICS)) {

            return parseStatement(tokens, STMT_ASSOCIATE_STATISTICS, parentNode, TYPE_ASSOCIATE_STATISTICS_STATEMENT);

        } else if (tokens.matches(STMT_AUDIT)) {

            return parseStatement(tokens, STMT_AUDIT, parentNode, TYPE_AUDIT_STATEMENT);

        } else if (tokens.matches(STMT_COMMIT_FORCE) || tokens.matches(STMT_COMMIT_WORK) || tokens.matches(STMT_COMMIT_WRITE)) {

            return parseStatement(tokens, STMT_COMMIT, parentNode, TYPE_COMMIT_STATEMENT);

        } else if (tokens.matches(STMT_DISASSOCIATE_STATISTICS)) {

            return parseStatement(tokens, STMT_DISASSOCIATE_STATISTICS, parentNode, TYPE_DISASSOCIATE_STATISTICS_STATEMENT);

        } else if (tokens.matches(STMT_EXPLAIN_PLAN)) {

            return parseStatement(tokens, STMT_EXPLAIN_PLAN, parentNode, TYPE_EXPLAIN_PLAN_STATEMENT);

        } else if (tokens.matches(STMT_FLASHBACK)) {

            return parseStatement(tokens, STMT_FLASHBACK, parentNode, TYPE_FLASHBACK_STATEMENT);

        } else if (tokens.matches(STMT_LOCK_TABLE)) {

            return parseStatement(tokens, STMT_LOCK_TABLE, parentNode, TYPE_LOCK_TABLE_STATEMENT);

        } else if (tokens.matches(STMT_MERGE)) {

            return parseStatement(tokens, STMT_MERGE, parentNode, TYPE_MERGE_STATEMENT);

        } else if (tokens.matches(STMT_NOAUDIT)) {

            return parseStatement(tokens, STMT_NOAUDIT, parentNode, TYPE_NOAUDIT_STATEMENT);

        } else if (tokens.matches(STMT_PURGE)) {

            return parseStatement(tokens, STMT_PURGE, parentNode, TYPE_PURGE_STATEMENT);

        } else if (tokens.matches(STMT_RENAME)) {

            return parseStatement(tokens, STMT_RENAME, parentNode, TYPE_RENAME_STATEMENT);

        } else if (tokens.matches(STMT_ROLLBACK)) {

            return parseStatement(tokens, STMT_ROLLBACK, parentNode, TYPE_ROLLBACK_STATEMENT);

        } else if (tokens.matches(STMT_ROLLBACK_WORK)) {

            return parseStatement(tokens, STMT_ROLLBACK_WORK, parentNode, TYPE_ROLLBACK_STATEMENT);

        } else if (tokens.matches(STMT_ROLLBACK_TO_SAVEPOINT)) {

            return parseStatement(tokens, STMT_ROLLBACK_TO_SAVEPOINT, parentNode, TYPE_ROLLBACK_STATEMENT);

        } else if (tokens.matches(STMT_SAVEPOINT)) {

            return parseStatement(tokens, STMT_SAVEPOINT, parentNode, TYPE_SAVEPOINT_STATEMENT);

        } else if (tokens.matches(STMT_TRUNCATE)) {

            return parseStatement(tokens, STMT_TRUNCATE, parentNode, TYPE_TRUNCATE_STATEMENT);

        }

        if (result == null) {

            result = super.parseCustomStatement(tokens, parentNode);

        }

        return result;

    }

    @Override

    protected AstNode parseCreateStatement( DdlTokenStream tokens,

                                            AstNode parentNode ) throws ParsingException {

        assert tokens != null;

        assert parentNode != null;

        if (tokens.matches(STMT_CREATE_INDEX) || tokens.matches(STMT_CREATE_UNIQUE_INDEX)

            || tokens.matches(STMT_CREATE_BITMAP_INDEX)) {

            return parseCreateIndex(tokens, parentNode);

        } else if (tokens.matches(STMT_CREATE_CLUSTER)) {

            return parseCreateClusterStatement(tokens, parentNode);

        } else if (tokens.matches(STMT_CREATE_CONTEXT)) {

            return parseStatement(tokens, STMT_CREATE_CONTEXT, parentNode, TYPE_CREATE_CONTEXT_STATEMENT);

        } else if (tokens.matches(STMT_CREATE_CONTROLFILE)) {

            return parseStatement(tokens, STMT_CREATE_CONTROLFILE, parentNode, TYPE_CREATE_CONTROLFILE_STATEMENT);

        } else if (tokens.matches(STMT_CREATE_DATABASE)) {

            return parseStatement(tokens, STMT_CREATE_DATABASE, parentNode, TYPE_CREATE_DATABASE_STATEMENT);

        } else if (tokens.matches(STMT_CREATE_PUBLIC_DATABASE)) {

            return parseStatement(tokens, STMT_CREATE_PUBLIC_DATABASE, parentNode, TYPE_CREATE_DATABASE_STATEMENT);

        } else if (tokens.matches(STMT_CREATE_DIMENSION)) {

            return parseCreateDimensionStatement(tokens, parentNode);

        } else if (tokens.matches(STMT_CREATE_DIRECTORY)) {

            return parseStatement(tokens, STMT_CREATE_DIRECTORY, parentNode, TYPE_CREATE_DIRECTORY_STATEMENT);

        } else if (tokens.matches(STMT_CREATE_OR_REPLACE_DIRECTORY)) {

            return parseStatement(tokens, STMT_CREATE_OR_REPLACE_DIRECTORY, parentNode, TYPE_CREATE_DIRECTORY_STATEMENT);

        } else if (tokens.matches(STMT_CREATE_DISKGROUP)) {

            return parseStatement(tokens, STMT_CREATE_DISKGROUP, parentNode, TYPE_CREATE_DISKGROUP_STATEMENT);

        } else if (tokens.matches(STMT_CREATE_FUNCTION)) {

            // ============ > PARSE UNTIL '/' for STMT_CREATE_FUNCTION

            return parseCreateFunctionStatement(tokens, parentNode);

        } else if (tokens.matches(STMT_CREATE_OR_REPLACE_FUNCTION)) {

            // ============ > PARSE UNTIL '/' for STMT_CREATE_OR_REPLACE_FUNCTION

            return parseCreateFunctionStatement(tokens, parentNode);

        } else if (tokens.matches(STMT_CREATE_INDEXTYPE)) {

            return parseStatement(tokens, STMT_CREATE_INDEXTYPE, parentNode, TYPE_CREATE_INDEXTYPE_STATEMENT);

        } else if (tokens.matches(STMT_CREATE_JAVA)) {

            return parseCreateJavaStatement(tokens, parentNode);

        } else if (tokens.matches(STMT_CREATE_LIBRARY)) {

            // ============ > PARSE UNTIL '/' for STMT_CREATE_LIBRARY

            return parseStatement(tokens, STMT_CREATE_LIBRARY, parentNode, TYPE_CREATE_LIBRARY_STATEMENT);

        } else if (tokens.matches(STMT_CREATE_OR_REPLACE_LIBRARY)) {

            // ============ > PARSE UNTIL '/' STMT_CREATE_OR_REPLACE_LIBRARY

            return parseStatement(tokens, STMT_CREATE_OR_REPLACE_LIBRARY, parentNode, TYPE_CREATE_LIBRARY_STATEMENT);

        } else if (tokens.matches(STMT_CREATE_MATERIALIZED_VIEW)) {

            return parseMaterializedViewStatement(tokens, parentNode);

        } else if (tokens.matches(STMT_CREATE_OPERATOR)) {

            return parseStatement(tokens, STMT_CREATE_OPERATOR, parentNode, TYPE_CREATE_OPERATOR_STATEMENT);

        } else if (tokens.matches(STMT_CREATE_OUTLINE)) {

            return parseStatement(tokens, STMT_CREATE_OUTLINE, parentNode, TYPE_CREATE_OUTLINE_STATEMENT);

        } else if (tokens.matches(STMT_CREATE_OR_REPLACE_OUTLINE)) {

            return parseStatement(tokens, STMT_CREATE_OR_REPLACE_OUTLINE, parentNode, TYPE_CREATE_OUTLINE_STATEMENT);

        } else if (tokens.matches(STMT_CREATE_PACKAGE)) {

            // ============ > PARSE UNTIL '/' for STMT_CREATE_PACKAGE

            return parseStatement(tokens, STMT_CREATE_PACKAGE, parentNode, TYPE_CREATE_PACKAGE_STATEMENT);

        } else if (tokens.matches(STMT_CREATE_OR_REPLACE_PACKAGE)) {

            // ============ > PARSE UNTIL '/' for STMT_CREATE_OR_REPLACE_PACKAGE

            return parseStatement(tokens, STMT_CREATE_OR_REPLACE_PACKAGE, parentNode, TYPE_CREATE_PACKAGE_STATEMENT);

        } else if (tokens.matches(STMT_CREATE_PFILE)) {

            return parseStatement(tokens, STMT_CREATE_PFILE, parentNode, TYPE_CREATE_PFILE_STATEMENT);

        } else if (tokens.matches(STMT_CREATE_PROCEDURE)) {

            // ============ > PARSE UNTIL '/' for STMT_CREATE_PROCEDURE

            return parseCreateProcedureStatement(tokens, parentNode);

        } else if (tokens.matches(STMT_CREATE_OR_REPLACE_PROCEDURE)) {

            // ============ > PARSE UNTIL '/' for STMT_CREATE_PROCEDURE

            return parseCreateProcedureStatement(tokens, parentNode);

        } else if (tokens.matches(STMT_CREATE_PROFILE)) {

            return parseStatement(tokens, STMT_CREATE_PROFILE, parentNode, TYPE_CREATE_PROFILE_STATEMENT);

        } else if (tokens.matches(STMT_CREATE_ROLE)) {

            return parseStatement(tokens, STMT_CREATE_ROLE, parentNode, TYPE_CREATE_ROLE_STATEMENT);

        } else if (tokens.matches(STMT_CREATE_ROLLBACK)) {

            return parseStatement(tokens, STMT_CREATE_ROLLBACK, parentNode, TYPE_CREATE_ROLLBACK_STATEMENT);

        } else if (tokens.matches(STMT_CREATE_PUBLIC_ROLLBACK)) {

            return parseStatement(tokens, STMT_CREATE_PUBLIC_ROLLBACK, parentNode, TYPE_CREATE_ROLLBACK_STATEMENT);

        } else if (tokens.matches(STMT_CREATE_SEQUENCE)) {

            return parseStatement(tokens, STMT_CREATE_SEQUENCE, parentNode, TYPE_CREATE_SEQUENCE_STATEMENT);

        } else if (tokens.matches(STMT_CREATE_SPFILE)) {

            return parseStatement(tokens, STMT_CREATE_SPFILE, parentNode, TYPE_CREATE_SPFILE_STATEMENT);

        } else if (tokens.matches(STMT_CREATE_SYNONYM)) {

            return parseStatement(tokens, STMT_CREATE_SYNONYM, parentNode, TYPE_CREATE_SYNONYM_STATEMENT);

        } else if (tokens.matches(STMT_CREATE_OR_REPLACE_SYNONYM)) {

            return parseStatement(tokens, STMT_CREATE_OR_REPLACE_SYNONYM, parentNode, TYPE_CREATE_SYNONYM_STATEMENT);

        } else if (tokens.matches(STMT_CREATE_OR_REPLACE_PUBLIC_SYNONYM)) {

            return parseStatement(tokens, STMT_CREATE_OR_REPLACE_PUBLIC_SYNONYM, parentNode, TYPE_CREATE_SYNONYM_STATEMENT);

        } else if (tokens.matches(STMT_CREATE_PUBLIC_SYNONYM)) {

            return parseStatement(tokens, STMT_CREATE_PUBLIC_SYNONYM, parentNode, TYPE_CREATE_SYNONYM_STATEMENT);

        } else if (tokens.matches(STMT_CREATE_TABLESPACE)) {

            return parseStatement(tokens, STMT_CREATE_TABLESPACE, parentNode, TYPE_CREATE_TABLESPACE_STATEMENT);

        } else if (tokens.matches(STMT_CREATE_TRIGGER)) {

            // ============ > PARSE UNTIL '/' for STMT_CREATE_OR_REPLACE_TRIGGER

            return parseSlashedStatement(tokens, STMT_CREATE_TRIGGER, parentNode, TYPE_CREATE_TRIGGER_STATEMENT);

        } else if (tokens.matches(STMT_CREATE_OR_REPLACE_TRIGGER)) {

            // ============ > PARSE UNTIL '/' for STMT_CREATE_OR_REPLACE_TRIGGER

            return parseSlashedStatement(tokens, STMT_CREATE_OR_REPLACE_TRIGGER, parentNode, TYPE_CREATE_TRIGGER_STATEMENT);

        } else if (tokens.matches(STMT_CREATE_TYPE)) {

            return parseStatement(tokens, STMT_CREATE_TYPE, parentNode, TYPE_CREATE_TYPE_STATEMENT);

        } else if (tokens.matches(STMT_CREATE_OR_REPLACE_TYPE)) {

            return parseStatement(tokens, STMT_CREATE_OR_REPLACE_TYPE, parentNode, TYPE_CREATE_TYPE_STATEMENT);

        } else if (tokens.matches(STMT_CREATE_USER)) {

            return parseStatement(tokens, STMT_CREATE_USER, parentNode, TYPE_CREATE_USER_STATEMENT);

        }

        return super.parseCreateStatement(tokens, parentNode);

    }

    private AstNode parseCreateClusterStatement( DdlTokenStream tokens,

                                                 AstNode parentNode ) throws ParsingException {

        markStartOfStatement(tokens);

        tokens.consume(STMT_CREATE_CLUSTER);

        String name = parseName(tokens);

        AstNode node = nodeFactory().node(name, parentNode, TYPE_CREATE_CLUSTER_STATEMENT);

        parseUntilTerminator(tokens);

        markEndOfStatement(tokens, node);

        return node;

    }

    private AstNode parseCreateDimensionStatement( DdlTokenStream tokens,

                                                   AstNode parentNode ) throws ParsingException {

        markStartOfStatement(tokens);

        tokens.consume(STMT_CREATE_DIMENSION);

        String name = parseName(tokens);

        AstNode node = nodeFactory().node(name, parentNode, TYPE_CREATE_DIMENSION_STATEMENT);

        parseUntilTerminator(tokens);

        markEndOfStatement(tokens, node);

        return node;

    }

    /**

     * Parses DDL CREATE FUNCTION statement

     *

     * @param tokens the tokenized {@link DdlTokenStream} of the DDL input content; may not be null

     * @param parentNode the parent {@link AstNode} node; may not be null

     * @return the parsed CREATE FUNCTION statement node

     * @throws ParsingException

     */

    protected AstNode parseCreateFunctionStatement( DdlTokenStream tokens,

                                                    AstNode parentNode ) throws ParsingException {

        assert tokens != null;

        assert parentNode != null;

        markStartOfStatement(tokens);

        /* ----------------------------------------------------------------------

            CREATE [ OR REPLACE ] FUNCTION [ schema. ] function_name

              [ ( parameter_declaration [, parameter_declaration] )

              ]

              RETURN datatype

              [ { invoker_rights_clause

                | DETERMINISTIC

                | parallel_enable_clause

                | result_cache_clause

                }...

              ]

              { { AGGREGATE | PIPELINED }

                USING [ schema. ] implementation_type

              | [ PIPELINED ] { IS | AS } { [ declare_section ] body | call_spec }

              } ;

           

            parameter_declaration = parameter_name [ IN | { { OUT | { IN OUT }} [ NOCOPY ] } ] datatype [ { := | DEFAULT } expression ]

        ---------------------------------------------------------------------- */

        boolean isReplace = tokens.canConsume(STMT_CREATE_OR_REPLACE_FUNCTION);

        tokens.canConsume(STMT_CREATE_FUNCTION);

        String name = parseName(tokens);

        AstNode node = nodeFactory().node(name, parentNode, TYPE_CREATE_FUNCTION_STATEMENT);

        if (isReplace) {

            // TODO: SET isReplace = TRUE to node (possibly a cnd mixin of "replaceable"

        }

        boolean ok = parseParameters(tokens, node);

        if (ok) {

            if (tokens.canConsume("RETURN")) {

                DataType dType = getDatatypeParser().parse(tokens);

                if (dType != null) {

                    getDatatypeParser().setPropertiesOnNode(node, dType);

                }

            }

        }

        parseUntilFwdSlash(tokens, false);

        tokens.canConsume("/");

        markEndOfStatement(tokens, node);

        return node;

    }

    /**

     * Parses DDL CREATE PROCEDURE statement

     *

     * @param tokens the tokenized {@link DdlTokenStream} of the DDL input content; may not be null

     * @param parentNode the parent {@link AstNode} node; may not be null

     * @return the parsed CREATE PROCEDURE statement node

     * @throws ParsingException

     */

    protected AstNode parseCreateProcedureStatement( DdlTokenStream tokens,

                                                     AstNode parentNode ) throws ParsingException {

        assert tokens != null;

        assert parentNode != null;

        markStartOfStatement(tokens);

        /* ----------------------------------------------------------------------

            CREATE [ OR REPLACE ] PROCEDURE [ schema. ] procedure_name

                [ ( parameter_declaration [, parameter_declaration ] ) ]

                [ AUTHID { CURRENT_USER | DEFINER  ]

                { IS | AS }

                { [ declare_section ] body | call_spec | EXTERNAL} ;

           

             call_spec = LANGUAGE { Java_declaration | C_declaration }

           

             Java_declaration = JAVA NAME string

           

             C_declaration =

                C [ NAME name ]

                    LIBRARY lib_name

                    [ AGENT IN (argument[, argument ]...) ]

                    [ WITH CONTEXT ]

                    [ PARAMETERS (parameter[, parameter ]...) ]

                   

            parameter_declaration = parameter_name [ IN | { { OUT | { IN OUT }} [ NOCOPY ] } ] datatype [ { := | DEFAULT } expression ]

        ---------------------------------------------------------------------- */

        boolean isReplace = tokens.canConsume(STMT_CREATE_OR_REPLACE_PROCEDURE);

        tokens.canConsume(STMT_CREATE_PROCEDURE);

        String name = parseName(tokens);

        AstNode node = nodeFactory().node(name, parentNode, TYPE_CREATE_PROCEDURE_STATEMENT);

        if (isReplace) {

            // TODO: SET isReplace = TRUE to node (possibly a cnd mixin of "replaceable"

        }

        boolean ok = parseParameters(tokens, node);

        if (ok) {

            if (tokens.canConsume("AUTHID")) {

                if (tokens.canConsume("CURRENT_USER")) {

                    node.setProperty(AUTHID_VALUE, "AUTHID CURRENT_USER");

                } else {

                    tokens.consume("DEFINER");

                    node.setProperty(AUTHID_VALUE, "DEFINER");

                }

            }

        }

        parseUntilFwdSlash(tokens, false);

        tokens.canConsume("/");

        markEndOfStatement(tokens, node);

        return node;

    }

    private boolean parseParameters( DdlTokenStream tokens,

                                     AstNode procedureNode ) throws ParsingException {

        assert tokens != null;

        assert procedureNode != null;

        // parameter_declaration = parameter_name [ IN | { { OUT | { IN OUT }} [ NOCOPY ] } ] datatype [ { := | DEFAULT }

        // expression ]

        // Assume we start with open parenthesis '(', then we parse comma separated list of function parameters

        // which have the form: [ parameter-Name ] DataType

        // So, try getting datatype, if datatype == NULL, then parseName() & parse datatype, then repeat as long as next token is

        // ","

        tokens.consume(L_PAREN); // EXPECTED

        while (!tokens.canConsume(R_PAREN)) {

            String paramName = parseName(tokens);

            String inOutStr = null;

            if (tokens.matches("IN")) {

                if (tokens.canConsume("IN", "OUT")) {

                    if (tokens.canConsume("NOCOPY")) {

                        inOutStr = "IN OUT NOCOPY";

                    } else {

                        inOutStr = "IN OUT";

                    }

                } else {

                    tokens.consume("IN");

                    inOutStr = "IN";

                }

            } else if (tokens.matches("OUT")) {

                if (tokens.canConsume("OUT", "NOCOPY")) {

                    inOutStr = "OUT NOCOPY";

                } else {

                    tokens.consume("OUT");

                    inOutStr = "OUT";

                }

            }

            DataType datatype = getDatatypeParser().parse(tokens);

            AstNode paramNode = nodeFactory().node(paramName, procedureNode, TYPE_FUNCTION_PARAMETER);

            if (datatype != null) {

                getDatatypeParser().setPropertiesOnNode(paramNode, datatype);

            }

            if (tokens.matchesAnyOf(":=", "DEFAULT") || !tokens.matchesAnyOf(COMMA, R_PAREN)) {

                String msg = DdlSequencerI18n.unsupportedProcedureParameterDeclaration.text(procedureNode.getName());

                DdlParserProblem problem = new DdlParserProblem(Problems.WARNING, getCurrentMarkedPosition(), msg);

                addProblem(problem, procedureNode);

                return false;

            }

            if (inOutStr != null) {

                paramNode.setProperty(IN_OUT_NO_COPY, inOutStr);

            }

            tokens.canConsume(COMMA);

        }

        return true;

    }

    /**

     * Parses DDL CREATE MATERIALIZED VIEW statement This could either be a standard view or a VIEW LOG ON statement.

     *

     * @param tokens the tokenized {@link DdlTokenStream} of the DDL input content; may not be null

     * @param parentNode the parent {@link AstNode} node; may not be null

     * @return the parsed CREATE MATERIALIZED VIEW statement node

     * @throws ParsingException

     */

    protected AstNode parseMaterializedViewStatement( DdlTokenStream tokens,

                                                      AstNode parentNode ) throws ParsingException {

        assert tokens != null;

        assert parentNode != null;

        markStartOfStatement(tokens);

        /* ----------------------------------------------------------------------

            CREATE MATERIALIZED VIEW

              [ schema. ]materialized_view

              [ column_alias [, column_alias]... ]

              [ OF [ schema. ]object_type ] .................... (MORE...)

            EXAMPLES:

           

                CREATE MATERIALIZED VIEW LOG ON products

                   WITH ROWID, SEQUENCE (prod_id)

                   INCLUDING NEW VALUES;

               

                CREATE MATERIALIZED VIEW sales_mv

                   BUILD IMMEDIATE

                   REFRESH FAST ON COMMIT

                   AS SELECT t.calendar_year, p.prod_id,

                      SUM(s.amount_sold) AS sum_sales

                      FROM times t, products p, sales s

                      WHERE t.time_id = s.time_id AND p.prod_id = s.prod_id

                      GROUP BY t.calendar_year, p.prod_id;

        ---------------------------------------------------------------------- */

        boolean isLog = tokens.canConsume(STMT_CREATE_MATERIALIZED_VEIW_LOG);

        tokens.canConsume(STMT_CREATE_MATERIALIZED_VIEW);

        String name = parseName(tokens);

        AstNode node = null;

        if (isLog) {

            node = nodeFactory().node(name, parentNode, TYPE_CREATE_MATERIALIZED_VIEW_LOG_STATEMENT);

        } else {

            node = nodeFactory().node(name, parentNode, TYPE_CREATE_MATERIALIZED_VIEW_STATEMENT);

        }

        parseUntilTerminator(tokens);

        markEndOfStatement(tokens, node);

        return node;

    }

    @Override

    protected AstNode parseGrantStatement( DdlTokenStream tokens,

                                           AstNode parentNode ) throws ParsingException {

        CheckArg.isNotNull(tokens, "tokens");

        CheckArg.isNotNull(parentNode, "parentNode");

        // GRANT { grant_system_privileges | grant_object_privileges } ;

        //

        // ** grant_system_privileges **

        //

        // { system_privilege | role | ALL PRIVILEGES } [, { system_privilege | role | ALL PRIVILEGES } ]...

        // TO grantee_clause [ WITH ADMIN OPTION ]

        //

        // ** grant_object_privileges **

        //

        // { object_privilege | ALL [ PRIVILEGES ] } [ (column [, column ]...) ] [, { object_privilege | ALL [ PRIVILEGES ] } [

        // (column [, column ]...) ] ]...

        // on_object_clause

        // TO grantee_clause [ WITH HIERARCHY OPTION ] [ WITH GRANT OPTION ]

        // ** on_object_clause **

        //

        // { [ schema. ] object | { DIRECTORY directory_name | JAVA { SOURCE | RESOURCE } [ schema. ] object } }

        //

        // ** grantee_clause **

        //

        // { user [ IDENTIFIED BY password ] | role | PUBLIC } [, { user [ IDENTIFIED BY password ] | role | PUBLIC } ]...

        AstNode node = null;

        // Original implementation does NOT parse Insert statement, but just returns a generic TypedStatement

        markStartOfStatement(tokens);

        tokens.consume(GRANT);

        String name = GRANT;

        tokens.consume(); // First Privilege token

        node = nodeFactory().node(name, parentNode, TYPE_GRANT_STATEMENT);

        while (tokens.hasNext()

               && !isTerminator(tokens)

               && (!tokens.matches(DdlTokenizer.STATEMENT_KEY) || (tokens.matches(DdlTokenizer.STATEMENT_KEY) && tokens.matches("GRANT",

                                                                                                                                "OPTION")))) {

            tokens.consume();

        }

        markEndOfStatement(tokens, node);

        return node;

        // if( tokens.matches(GRANT, DdlTokenStream.ANY_VALUE, "TO")) {

        // markStartOfStatement(tokens);

        // tokens.consume(GRANT);

        // String privilege = tokens.consume();

        // tokens.consume("TO");

        // tokens.consume(); // TO Value

        // && problem != null

        // String value = parseUntilTerminator(tokens);

        //

        // AstNode grantNode = nodeFactory().node("GRANT", parentNode, TYPE_GRANT_STATEMENT);

        // markEndOfStatement(tokens, grantNode);

        //

        // return grantNode;

        // } else if( tokens.matches(GRANT, DdlTokenStream.ANY_VALUE, COMMA)) {

        // markStartOfStatement(tokens);

        // tokens.consume(GRANT);

        // String privilege = tokens.consume();

        // // Assume Multiple Privileges

        // while( tokens.canConsume(COMMA)) {

        // tokens.consume(); // Next privilege

        // }

        //

        // tokens.consume("ON");

        // tokens.consume(); // TO Value

        //

        // tokens.canConsume("WITH", GRANT);

        //

        // String value = parseUntilTerminator(tokens);

        //

        // AstNode grantNode = nodeFactory().node("GRANT", parentNode, TYPE_GRANT_STATEMENT);

        // markEndOfStatement(tokens, grantNode);

        //

        // return grantNode;

        // } else if( tokens.matches(GRANT, DdlTokenStream.ANY_VALUE, "ON", DdlTokenStream.ANY_VALUE, "TO",

        // DdlTokenStream.ANY_VALUE, "WITH", GRANT)) {

        // markStartOfStatement(tokens);

        // //GRANT ALL ON bonuses TO hr WITH GRANT OPTION;

        //

        // tokens.consume(GRANT);

        // String privilege = tokens.consume();

        // tokens.consume("ON");

        // tokens.consume(); // ON Value

        // tokens.consume("TO");

        // tokens.consume();

        // tokens.consume("WITH", GRANT);

        // String value = parseUntilTerminator(tokens);

        //

        // AstNode grantNode = nodeFactory().node("GRANT", parentNode, TYPE_GRANT_STATEMENT);

        // markEndOfStatement(tokens, grantNode);

        //

        // return grantNode;

        // }

        // else if( tokens.matches(GRANT, DdlTokenStream.ANY_VALUE, "ON")) {

        // tokens.consume(GRANT);

        // String privilege = tokens.consume();

        // tokens.consume("ON");

        // tokens.consume(); // ON Value

        //

        // String value = parseUntilTerminator(tokens);

        // stmt.appendSource(true, value);&& problem != null

        // stmt.setType("GRANT" + SPACE + privilege + SPACE + "ON");

        // consumeTerminator(tokens);

        // } else if( tokens.matches(GRANT, CREATE) ||

        // tokens.matches(GRANT, ALTER) ||

        // tokens.matches(GRANT, DROP) ||

        // tokens.matches(GRANT, "EXECUTE") ||

        // tokens.matches(GRANT, "MANAGE") ||

        // tokens.matches(GRANT, "QUERY") ||

        // tokens.matches(GRANT, "ON", "COMMIT") ||

        // tokens.matches(GRANT, "ANY") ||

        // tokens.matches(GRANT, "SELECT") ||

        // tokens.matches(GRANT, "RESTRICTED") ||

        // //

        // ========================================================================================================================

        // ===

        // //

        // ========================================================================================================================

        // ===

        // tokens.matches(GRANT, "FLASHBACK") ||

        // tokens.matches(GRANT, "GLOBAL") ||

        // tokens.matches(GRANT, "DEBUG") ||

        // tokens.matches(GRANT, "GLOBAL") ||

        // tokens.matches(GRANT, "ADVISOR") ||

        // tokens.matches(GRANT, "ADMINISTER") ||

        // tokens.matches(GRANT, "BACKUP") ||

        // tokens.matches(GRANT, "LOCK") ||

        // tokens.matches(GRANT, "UPDATE") ||

        // tokens.matches(GRANT, "DELETE") ||

        // tokens.matches(GRANT, "INSERT") ||

        // tokens.matches(GRANT, "UNLIMITED") ||

        // tokens.matches(GRANT, "UNDER") ||

        // tokens.matches(GRANT, "ANALYZE") ||

        // tokens.matches(GRANT, "AUDIT") ||

        // tokens.matches(GRANT, "COMMENT") ||

        // tokens.matches(GRANT, "EXEMPT") ||

        // tokens.matches(GRANT, "FORCE") ||

        // tokens.matches(GRANT, "RESUMABLE") ||

        // tokens.matches(GRANT, "SYSDBA") ||

        // tokens.matches(GRANT, "REFERENCES") ||

        // tokens.matches(GRANT, "SYSOPER") ||

        // tokens.matches(GRANT, "WRITE") ) {

        // tokens.consume(GRANT);

        //

        // String nextTok = tokens.consume() + SPACE + tokens.consume() + SPACE + tokens.consume();

        //

        // String value = parseUntilTerminator(tokens);

        // stmt.setType("GRANT" + SPACE + nextTok);

        // consumeTerminator(tokens);

        // }

        //

        //

        // return grantNode;

        // return super.parseGrantStatement(tokens, parentNode);

    }

    /**

     * {@inheritDoc}

     *

     * @see org.modeshape.sequencer.ddl.StandardDdlParser#parseRevokeStatement(org.modeshape.sequencer.ddl.DdlTokenStream,

     *      org.modeshape.sequencer.ddl.node.AstNode)

     */

    @Override

    protected AstNode parseRevokeStatement( DdlTokenStream tokens,

                                            AstNode parentNode ) throws ParsingException {

        return parseStatement(tokens, STMT_REVOKE, parentNode, TYPE_REVOKE_STATEMENT);