package gudusoft.gsqlparser.parser;

import gudusoft.gsqlparser.EDbVendor;
import gudusoft.gsqlparser.TBaseType;
import gudusoft.gsqlparser.TCustomLexer;
import gudusoft.gsqlparser.TCustomParser;
import gudusoft.gsqlparser.TCustomSqlStatement;
import gudusoft.gsqlparser.TLexerOdbc;
import gudusoft.gsqlparser.TParserOdbc;
import gudusoft.gsqlparser.TSourceToken;
import gudusoft.gsqlparser.TSourceTokenList;
import gudusoft.gsqlparser.TStatementList;
import gudusoft.gsqlparser.TSyntaxError;
import gudusoft.gsqlparser.EFindSqlStateType;
import gudusoft.gsqlparser.ETokenType;
import gudusoft.gsqlparser.ETokenStatus;
import gudusoft.gsqlparser.ESqlStatementType;
import gudusoft.gsqlparser.EErrorType;
import gudusoft.gsqlparser.stmt.TUnknownSqlStatement;
import gudusoft.gsqlparser.stmt.mssql.TMssqlBlock;
import gudusoft.gsqlparser.stmt.mssql.TMssqlExecute;
import gudusoft.gsqlparser.sqlcmds.ISqlCmds;
import gudusoft.gsqlparser.sqlcmds.SqlCmdsFactory;
import gudusoft.gsqlparser.compiler.TContext;
import gudusoft.gsqlparser.sqlenv.TSQLEnv;
import gudusoft.gsqlparser.compiler.TGlobalScope;
import gudusoft.gsqlparser.compiler.TFrame;
import gudusoft.gsqlparser.resolver.TSQLResolver;
import gudusoft.gsqlparser.TLog;
import gudusoft.gsqlparser.compiler.TASTEvaluator;

import java.io.BufferedReader;
import java.util.ArrayList;
import java.util.List;
import java.util.Stack;

import static gudusoft.gsqlparser.ESqlStatementType.sstmssqlreturn;

/**
 * ODBC database SQL parser implementation.
 *
 * <p>This parser handles ODBC-specific SQL syntax including:
 * <ul>
 *   <li>ODBC escape sequences ({ ... })</li>
 *   <li>ODBC date/time literals ({ d 'date' }, { t 'time' }, { ts 'timestamp' })</li>
 *   <li>ODBC function calls ({ fn function_name(...) })</li>
 *   <li>ODBC outer join syntax ({ oj outer_join })</li>
 *   <li>ODBC CALL statements ({ call procedure_name(...) })</li>
 *   <li>Base MSSQL syntax (inherited)</li>
 * </ul>
 *
 * <p><b>Design Notes:</b>
 * <ul>
 *   <li>Extends {@link AbstractSqlParser} using the template method pattern</li>
 *   <li>Uses {@link TLexerOdbc} for tokenization</li>
 *   <li>Uses {@link TParserOdbc} for parsing</li>
 *   <li>Based on MSSQL parser with ODBC escape sequence handling</li>
 *   <li>Delimiter character: ';' for SQL statements</li>
 * </ul>
 *
 * <p><b>Usage Example:</b>
 * <pre>
 * // Get ODBC parser from factory
 * SqlParser parser = SqlParserFactory.get(EDbVendor.dbvodbc);
 *
 * // Build context
 * ParserContext context = new ParserContext.Builder(EDbVendor.dbvodbc)
 *     .sqlText("SELECT * FROM Employees WHERE hire_date > { d '2020-01-01' }")
 *     .build();
 *
 * // Parse
 * SqlParseResult result = parser.parse(context);
 *
 * // Access statements
 * TStatementList statements = result.getSqlStatements();
 * </pre>
 *
 * @see SqlParser
 * @see AbstractSqlParser
 * @see TLexerOdbc
 * @see TParserOdbc
 * @since 3.3.0.0
 */
public class OdbcSqlParser extends AbstractSqlParser {

    /**
     * Construct ODBC SQL parser.
     * <p>
     * Configures the parser for ODBC database with default delimiter (;).
     * <p>
     * Following the original TGSqlParser pattern, the lexer and parser are
     * created once in the constructor and reused for all parsing operations.
     */
    public OdbcSqlParser() {
        super(EDbVendor.dbvodbc);
        this.delimiterChar = ';';
        this.defaultDelimiterStr = ";";

        // Create lexer once - will be reused for all parsing operations
        this.flexer = new TLexerOdbc();
        this.flexer.delimiterchar = this.delimiterChar;
        this.flexer.defaultDelimiterStr = this.defaultDelimiterStr;

        // Set parent's lexer reference for shared tokenization logic
        this.lexer = this.flexer;

        // Create parser once - will be reused for all parsing operations
        this.fparser = new TParserOdbc(null);
        this.fparser.lexer = this.flexer;
    }

    // ========== Parser Components ==========

    /** The ODBC lexer used for tokenization */
    public TLexerOdbc flexer;

    /** SQL parser (for ODBC statements) */
    private TParserOdbc fparser;

    /** Current statement being built during extraction */
    private TCustomSqlStatement gcurrentsqlstatement;

    // Note: Global context and frame stack fields inherited from AbstractSqlParser:
    // - protected TContext globalContext
    // - protected TSQLEnv sqlEnv
    // - protected Stack<TFrame> frameStack
    // - protected TFrame globalFrame

    // ========== AbstractSqlParser Abstract Methods Implementation ==========

    /**
     * Return the ODBC lexer instance.
     */
    @Override
    protected TCustomLexer getLexer(ParserContext context) {
        return this.flexer;
    }

    /**
     * Return the ODBC SQL parser instance with updated token list.
     */
    @Override
    protected TCustomParser getParser(ParserContext context, TSourceTokenList tokens) {
        this.fparser.sourcetokenlist = tokens;
        return this.fparser;
    }

    /**
     * Call ODBC-specific tokenization logic.
     * <p>
     * Delegates to doodbcsqltexttotokenlist which handles ODBC's
     * specific escape sequences and MSSQL base syntax.
     */
    @Override
    protected void tokenizeVendorSql() {
        doodbcsqltexttotokenlist();
    }

    /**
     * Setup ODBC parser for raw statement extraction.
     * <p>
     * ODBC uses a single parser, so we inject sqlcmds and update
     * the token list for the main parser only.
     */
    @Override
    protected void setupVendorParsersForExtraction() {
        // Inject sqlcmds into parser (required for make_stmt)
        this.fparser.sqlcmds = this.sqlcmds;

        // Update token list for parser
        this.fparser.sourcetokenlist = this.sourcetokenlist;
    }

    /**
     * Call ODBC-specific raw statement extraction logic.
     * <p>
     * Delegates to doodbcgetrawsqlstatements which handles ODBC's
     * statement delimiters (inherits from MSSQL: semicolon and GO command).
     */
    @Override
    protected void extractVendorRawStatements(SqlParseResult.Builder builder) {
        doodbcgetrawsqlstatements(builder);
    }

    /**
     * Perform full parsing of statements with syntax checking.
     * <p>
     * This method orchestrates the parsing of all statements.
     */
    @Override
    protected TStatementList performParsing(ParserContext context,
                                           TCustomParser parser,
                                           TCustomParser secondaryParser,
                                           TSourceTokenList tokens,
                                           TStatementList rawStatements) {
        // Store references
        this.fparser = (TParserOdbc) parser;
        this.sourcetokenlist = tokens;
        this.parserContext = context;

        // Use the raw statements passed from AbstractSqlParser.parse()
        this.sqlstatements = rawStatements;

        // Initialize statement parsing infrastructure
        this.sqlcmds = SqlCmdsFactory.get(vendor);

        // Inject sqlcmds into parser (required for make_stmt and other methods)
        this.fparser.sqlcmds = this.sqlcmds;

        // Initialize global context for semantic analysis
        initializeGlobalContext();

        // Parse each statement with exception handling for robustness
        for (int i = 0; i < sqlstatements.size(); i++) {
            TCustomSqlStatement stmt = sqlstatements.getRawSql(i);

            try {
                stmt.setFrameStack(frameStack);

                // Parse the statement
                int parseResult = stmt.parsestatement(null, false, context.isOnlyNeedRawParseTree());

                // Handle error recovery for CREATE TABLE/INDEX
                boolean doRecover = TBaseType.ENABLE_ERROR_RECOVER_IN_CREATE_TABLE;
                if (doRecover && ((parseResult != 0) || (stmt.getErrorCount() > 0))) {
                    handleCreateTableErrorRecovery(stmt);
                }

                // Collect syntax errors
                if ((parseResult != 0) || (stmt.getErrorCount() > 0)) {
                    copyErrorsFromStatement(stmt);
                }

            } catch (Exception ex) {
                // Use inherited exception handler from AbstractSqlParser
                // This provides consistent error handling across all database parsers
                handleStatementParsingException(stmt, i, ex);
                continue;
            }
        }

        // Clean up frame stack
        if (globalFrame != null) {
            globalFrame.popMeFromStack(frameStack);
        }

        return this.sqlstatements;
    }

    // Note: initializeGlobalContext() inherited from AbstractSqlParser
    // Note: No override of afterStatementParsed() needed - default (no-op) is appropriate for ODBC

    /**
     * Handle error recovery for CREATE TABLE/INDEX statements.
     */
    private void handleCreateTableErrorRecovery(TCustomSqlStatement stmt) {
        if (((stmt.sqlstatementtype == ESqlStatementType.sstcreatetable)
                || (stmt.sqlstatementtype == ESqlStatementType.sstcreateindex))
                && (!TBaseType.c_createTableStrictParsing)) {

            int nested = 0;
            boolean isIgnore = false, isFoundIgnoreToken = false;
            TSourceToken firstIgnoreToken = null;

            for (int k = 0; k < stmt.sourcetokenlist.size(); k++) {
                TSourceToken st = stmt.sourcetokenlist.get(k);
                if (isIgnore) {
                    if (st.issolidtoken() && (st.tokencode != ';')) {
                        isFoundIgnoreToken = true;
                        if (firstIgnoreToken == null) {
                            firstIgnoreToken = st;
                        }
                    }
                    if (st.tokencode != ';') {
                        st.tokencode = TBaseType.sqlpluscmd;
                    }
                    continue;
                }
                if (st.tokencode == (int) ')') {
                    nested--;
                    if (nested == 0) {
                        boolean isSelect = false;
                        TSourceToken st1 = st.searchToken(TBaseType.rrw_as, 1);
                        if (st1 != null) {
                            TSourceToken st2 = st.searchToken((int) '(', 2);
                            if (st2 != null) {
                                TSourceToken st3 = st.searchToken(TBaseType.rrw_select, 3);
                                isSelect = (st3 != null);
                            }
                        }
                        if (!isSelect) isIgnore = true;
                    }
                } else if (st.tokencode == (int) '(') {
                    nested++;
                }
            }

            if (isFoundIgnoreToken) {
                stmt.clearError();
                stmt.parsestatement(null, false);
            }
        }
    }

    /**
     * Perform ODBC-specific semantic analysis using TSQLResolver.
     */
    @Override
    protected void performSemanticAnalysis(ParserContext context, TStatementList statements) {
        if (TBaseType.isEnableResolver() && getSyntaxErrors().isEmpty()) {
            TSQLResolver resolver = new TSQLResolver(globalContext, statements);
            resolver.resolve();
        }
    }

    /**
     * Perform interpretation/evaluation on parsed statements.
     */
    @Override
    protected void performInterpreter(ParserContext context, TStatementList statements) {
        if (TBaseType.ENABLE_INTERPRETER && getSyntaxErrors().isEmpty()) {
            TLog.clearLogs();
            TGlobalScope interpreterScope = new TGlobalScope(sqlEnv);
            TLog.enableInterpreterLogOnly();
            TASTEvaluator astEvaluator = new TASTEvaluator(statements, interpreterScope);
            astEvaluator.eval();
        }
    }

    // ========== ODBC-Specific Tokenization ==========

    /**
     * ODBC-specific tokenization logic.
     * <p>
     * Extracted from: TGSqlParser.doodbcsqltexttotokenlist() (lines 4119-4148)
     * <p>
     * This method first performs MSSQL tokenization, then post-processes
     * the token list to handle ODBC escape sequences:
     * <ul>
     *   <li>{ d 'date' } - ODBC date literal</li>
     *   <li>{ t 'time' } - ODBC time literal</li>
     *   <li>{ ts 'timestamp' } - ODBC timestamp literal</li>
     *   <li>{ fn function(...) } - ODBC function call</li>
     *   <li>{ oj outer_join } - ODBC outer join</li>
     *   <li>{ call procedure(...) } - ODBC procedure call</li>
     * </ul>
     */
    private void doodbcsqltexttotokenlist() {
        boolean insideODBC = false;
        TSourceToken odbcPrefix = null;

        // First, perform MSSQL tokenization
        domssqlsqltexttotokenlist();

        // Then post-process for ODBC escape sequences
        for (int i = 0; i < sourcetokenlist.size(); i++) {
            TSourceToken ast = sourcetokenlist.get(i);

            // Entering ODBC escape sequence
            if ((ast.tokencode == '{') || (ast.tokencode == TBaseType.odbc_esc_prefix)) {
                insideODBC = true;
                odbcPrefix = ast;
            }

            // Exiting ODBC escape sequence
            if ((ast.tokencode == '}') || (ast.tokencode == TBaseType.odbc_esc_terminator)) {
                insideODBC = false;
                odbcPrefix = null;
            }

            // Convert ODBC keywords to identifiers when NOT inside ODBC blocks
            if (((ast.tokencode == TBaseType.rrw_odbc_d)
                    || (ast.tokencode == TBaseType.rrw_odbc_t)
                    || (ast.tokencode == TBaseType.rrw_odbc_ts)
                    || (ast.tokencode == TBaseType.rrw_odbc_fn)
                    || (ast.tokencode == TBaseType.rrw_odbc_oj)
                ) && (!insideODBC)) {
                ast.tokencode = TBaseType.ident;
            }

            // Link CALL statements to ODBC prefix when inside ODBC blocks
            if ((ast.tokencode == TBaseType.rrw_call) && (insideODBC)) {
                odbcPrefix.setLinkToken(ast);
            }
        }
    }

    /**
     * MSSQL-specific tokenization logic (inherited behavior).
     * <p>
     * This is the base tokenization used by ODBC before ODBC-specific
     * post-processing.
     */
    private void domssqlsqltexttotokenlist() {
        TSourceToken lcprevtoken = null;
        int lcsteps = 0;
        TSourceToken asourcetoken, lctoken, lctoken2, lctoken3;
        int yychar;
        boolean iskeywordgo;

        asourcetoken = getanewsourcetoken();

        if (asourcetoken == null) return;

        yychar = asourcetoken.tokencode;

        boolean lcinopenrowset = false;
        int lcnested = 0;

        while (yychar > 0) {

            if (asourcetoken.tokencode == TBaseType.rrw_openrowset) {
                // openrowset(....)
                lcinopenrowset = true;
                lcnested = 0;
            } else if (asourcetoken.tokentype == ETokenType.ttleftparenthesis) {
                if ((lcsteps > 0) && TBaseType.assigned(lcprevtoken)) {
                    if (lcprevtoken.tokencode == TBaseType.rrw_primary) {
                        lcprevtoken.tokencode = TBaseType.rrw_select - 2;  //rw_primary2
                        checkconstarinttoken(lcprevtoken);
                    } else if (lcprevtoken.tokencode == TBaseType.rrw_foreign) {
                        lcprevtoken.tokencode = TBaseType.rrw_select - 4;  //rw_foreign2
                        checkconstarinttoken(lcprevtoken);
                    } else if (lcprevtoken.tokencode == TBaseType.rrw_unique) {
                        lcprevtoken.tokencode = TBaseType.rrw_select - 1;  //rw_unique2
                        checkconstarinttoken(lcprevtoken);
                    }
                    lcprevtoken = null;
                    lcsteps = 0;
                }

                // openrowset(....)
                if (lcinopenrowset)
                    lcnested++;
            } else if (asourcetoken.tokentype == ETokenType.ttrightparenthesis) {
                // openrowset(....)
                if (lcinopenrowset) {
                    if ((lcnested > 0))
                        lcnested--;
                    if (lcnested == 0)
                        lcinopenrowset = false;
                }
            } else if (asourcetoken.tokentype == ETokenType.ttsemicolon) {
                if (lcinopenrowset) {
                    asourcetoken.tokentype = ETokenType.ttsemicolon2;
                } else {
                    lctoken2 = asourcetoken.searchToken(TBaseType.rrw_begin, -1);
                    if (lctoken2 != null) {
                        asourcetoken.tokencode = TBaseType.SEMI_COLON_AFTER_BEGIN;
                        asourcetoken.tokentype = ETokenType.ttsemicolon3;
                    } else {
                        lctoken2 = asourcetoken.searchToken(TBaseType.rrw_try, -1);
                        if (lctoken2 == null) {
                            lctoken2 = asourcetoken.searchToken(TBaseType.rrw_catch, -1);
                        }
                        if (lctoken2 != null) {
                            lctoken3 = asourcetoken.searchToken(TBaseType.rrw_begin, -2);
                            if (lctoken3 != null) {
                                asourcetoken.tokencode = TBaseType.SEMI_COLON_AFTER_BEGIN;
                                asourcetoken.tokentype = ETokenType.ttsemicolon3;
                            }
                        }
                    }
                }

                lctoken = getprevtoken(asourcetoken);
                if ((lctoken != null)) {
                    if (lctoken.tokentype == ETokenType.ttsemicolon) {
                        // treat this semicolon as a whitespace
                        asourcetoken.tokencode = TBaseType.lexspace;
                    }
                }
            } else if (asourcetoken.tokentype == ETokenType.ttperiod) {
                lctoken = getprevtoken(asourcetoken);
                if (TBaseType.assigned(lctoken)) {
                    // go.fieldname, go is a table alias, not a go statement
                    if (lctoken.tokencode == TBaseType.rrw_go) {
                        lctoken.tokencode = TBaseType.ident;
                        lctoken.tokentype = ETokenType.ttidentifier;
                    }
                }
            } else if (asourcetoken.tokencode == TBaseType.rrw_table) {
                lctoken = getprevtoken(asourcetoken);
                if (TBaseType.assigned(lctoken)) {
                    if (lctoken.tokencode == TBaseType.rrw_lock) {
                        lctoken.tokencode = TBaseType.rw_locktable;
                    }
                }
            } else if (asourcetoken.tokencode == TBaseType.rrw_into) {
                lctoken = getprevtoken(asourcetoken);
                if (TBaseType.assigned(lctoken)) {
                    if (lctoken.tokencode == TBaseType.rrw_sqlserver_copy) {
                        lctoken.tokencode = TBaseType.rrw_sqlserver_copyinto;
                    }
                }
            } else if (asourcetoken.tokencode == TBaseType.rrw_sqlserver_column) {
                lctoken = getprevtoken(asourcetoken);
                if (TBaseType.assigned(lctoken)) {
                    if (lctoken.tokencode == TBaseType.rrw_drop) {
                        asourcetoken.tokencode = TBaseType.rrw_sqlserver_drop_column;
                    }
                }
            } else if (asourcetoken.tokencode == TBaseType.rrw_go) {
                iskeywordgo = true;
                lctoken = getprevtoken(asourcetoken);
                if (TBaseType.assigned(lctoken)) {
                    // go should not at same line as other sql statement
                    if ((lctoken.lineNo == asourcetoken.lineNo) && (lctoken.tokencode != ';')) {
                        iskeywordgo = false;
                    }
                }

                if (iskeywordgo) {
                    lcinopenrowset = false;
                    lcnested = 0;
                    lcprevtoken = asourcetoken;
                } else {
                    asourcetoken.tokencode = TBaseType.ident;
                    asourcetoken.tokentype = ETokenType.ttidentifier;
                }
            } else if (asourcetoken.tokencode == TBaseType.rrw_primary) {
                // primary key [clustered | nonclustered ] [hash] ( column list)
                lcsteps = 2;
                lcprevtoken = asourcetoken;
            } else if (asourcetoken.tokencode == TBaseType.rrw_foreign) {
                // foreign key [clustered | nonclustered ] ( column list)
                lcsteps = 2;
                lcprevtoken = asourcetoken;
            } else if (asourcetoken.tokencode == TBaseType.rrw_unique) {
                // unique [clustered | nonclustered ] [hash] ( column list)
                lcsteps = 1;
                lcprevtoken = asourcetoken;
            } else if (asourcetoken.issolidtoken()) {
                if (lcsteps > 0) {
                    if (!(TBaseType.mysametext("clustered", asourcetoken.toString())
                            || TBaseType.mysametext("nonclustered", asourcetoken.toString())
                            || TBaseType.mysametext("hash", asourcetoken.toString())
                    ))
                        lcsteps--;
                }
            }

            sourcetokenlist.add(asourcetoken);

            asourcetoken = getanewsourcetoken();
            if (asourcetoken == null) break;
            yychar = asourcetoken.tokencode;
        }
    }

    /**
     * Get previous token in token list.
     */
    private TSourceToken getprevtoken(TSourceToken currentToken) {
        if (currentToken == null || currentToken.posinlist == 0) {
            return null;
        }

        for (int i = currentToken.posinlist - 1; i >= 0; i--) {
            TSourceToken token = this.sourcetokenlist.get(i);
            if (token.issolidtoken()) {
                return token;
            }
        }
        return null;
    }

    /**
     * Check and adjust constraint token codes.
     * <p>
     * When PRIMARY KEY, FOREIGN KEY, or UNIQUE is followed by '(', we need to
     * look back to see if there's a CONSTRAINT keyword. If found, change its
     * token code from rrw_constraint (515) to rw_constraint2 (298).
     *
     * @param token The token after which to search (PRIMARY/FOREIGN/UNIQUE)
     */
    private void checkconstarinttoken(TSourceToken token) {
        TSourceTokenList lcStList = token.container;
        if (TBaseType.assigned(lcStList)) {
            // Look back 2 solid tokens to find CONSTRAINT keyword
            TSourceToken lcPPToken = lcStList.nextsolidtoken(token.posinlist, -2, false);
            if (TBaseType.assigned(lcPPToken)) {
                if (lcPPToken.tokencode == flexer.getkeywordvalue("constraint")) {
                    // Change CONSTRAINT to special constraint2 token code
                    lcPPToken.tokencode = TBaseType.rw_constraint2;
                }
            }
        }
    }

    // ========== ODBC-Specific Raw Statement Extraction ==========

    /**
     * ODBC-specific raw statement extraction logic.
     * <p>
     * Extracted from: TGSqlParser.doodbcgetrawsqlstatements() (lines 12848-12850)
     * <p>
     * ODBC uses the same statement extraction logic as MSSQL.
     */
    private void doodbcgetrawsqlstatements(SqlParseResult.Builder builder) {
        domssqlgetrawsqlstatements(builder);
    }

    /**
     * MSSQL-specific raw statement extraction logic (inherited behavior).
     * <p>
     * This is the same extraction logic used by MSSQL, handling:
     * <ul>
     *   <li>Semicolon statement terminators</li>
     *   <li>GO batch separators</li>
     *   <li>BEGIN/END blocks</li>
     *   <li>TRY/CATCH blocks</li>
     *   <li>Stored procedures, functions, and triggers</li>
     * </ul>
     */
    private void domssqlgetrawsqlstatements(SqlParseResult.Builder builder) {
        int errorcount = 0;
        int case_end_nest = 0;

        if (TBaseType.assigned(sqlstatements)) sqlstatements.clear();
        if (!TBaseType.assigned(sourcetokenlist)) {
            builder.errorCode(-1);
            builder.errorMessage("Source token list is null");
            return;
        }

        gcurrentsqlstatement = null;
        EFindSqlStateType gst = EFindSqlStateType.stnormal;
        int lcblocklevel = 0;
        int lctrycatchlevel = 0;
        TSourceToken lcprevsolidtoken = null, lcnextsolidtoken, lcnnextsolidtoken;
        TSourceToken ast = null;
        int i, lcMergeInSelectNested = 0;
        boolean lcisendconversation, lcstillinsql, lcMergeInSelect = false;

        for (i = 0; i < sourcetokenlist.size(); i++) {

            if ((ast != null) && (ast.issolidtoken()))
                lcprevsolidtoken = ast;

            ast = sourcetokenlist.get(i);
            sourcetokenlist.curpos = i;

            if (ast.tokencode == TBaseType.rrw_for) {
                TSourceToken st1 = ast.nextSolidToken();
                if ((st1 != null) && (st1.tokencode == TBaseType.rrw_system_time)) {
                    ast.tokencode = TBaseType.rw_for_system_time;
                }
            }

            if (lcMergeInSelect) {
                if (ast.tokencode == '(') lcMergeInSelectNested++;
                if (ast.tokencode == ')') {
                    lcMergeInSelectNested--;
                    if (lcMergeInSelectNested == 0) {
                        lcMergeInSelect = false;
                    }
                }
                gcurrentsqlstatement.sourcetokenlist.add(ast);
                continue;
            }

            if (ast.tokenstatus == ETokenStatus.tsignoredbygetrawstatement) {
                gcurrentsqlstatement.sourcetokenlist.add(ast);
                continue;
            }

            if (ast.tokencode == TBaseType.rrw_minus) {
                TSourceToken st1 = ast.searchToken('(', 1);
                if (st1 == null) {
                    st1 = ast.searchToken(TBaseType.rrw_select, 1);
                    if (st1 == null) {
                        ast.tokencode = TBaseType.ident;
                    }
                }
            } else if (ast.tokencode == TBaseType.rrw_merge) {
                TSourceToken st1 = ast.nextSolidToken();
                if (st1.tokencode == TBaseType.rrw_join) {
                    ast.tokencode = TBaseType.rrw_merge2_sqlserver;
                }
                if ((lcprevsolidtoken != null) && (lcprevsolidtoken.tokencode == '(')) {
                    lcMergeInSelect = true;
                    lcMergeInSelectNested++;
                    gcurrentsqlstatement.sourcetokenlist.add(ast);
                    continue;
                }
            } else if (ast.tokencode == TBaseType.rrw_sqlserver_value) {
                if ((lcprevsolidtoken != null) && (lcprevsolidtoken.tokencode == '.')) {
                    TSourceToken st1 = ast.searchToken('(', 1);
                    if (st1 != null) {
                        ast.tokencode = TBaseType.rrw_xml_value;
                    }
                }
            } else if (ast.tokencode == TBaseType.rrw_sqlserver_modify) {
                if ((lcprevsolidtoken != null) && (lcprevsolidtoken.tokencode == '.')) {
                    TSourceToken st1 = ast.searchToken('(', 1);
                    if (st1 != null) {
                        ast.tokencode = TBaseType.rrw_xml_modify;
                    }
                }
            } else if (ast.tokencode == TBaseType.rrw_sqlserver_query) {
                if ((lcprevsolidtoken != null) && (lcprevsolidtoken.tokencode == '.')) {
                    TSourceToken st1 = ast.searchToken('(', 1);
                    if (st1 != null) {
                        ast.tokencode = TBaseType.rrw_xml_query;
                    }
                }
            } else if (ast.tokencode == TBaseType.rrw_sqlserver_exist) {
                if ((lcprevsolidtoken != null) && (lcprevsolidtoken.tokencode == '.')) {
                    TSourceToken st1 = ast.searchToken('(', 1);
                    if (st1 != null) {
                        ast.tokencode = TBaseType.rrw_xml_exist;
                    }
                }
            } else if (ast.tokencode == TBaseType.rrw_sqlserver_nodes) {
                if ((lcprevsolidtoken != null) && (lcprevsolidtoken.tokencode == '.')) {
                    TSourceToken st1 = ast.searchToken('(', 1);
                    if (st1 != null) {
                        ast.tokencode = TBaseType.rrw_xml_nodes;
                    }
                }
            } else if (ast.tokencode == TBaseType.rrw_check) {
                if ((lcprevsolidtoken != null) && (lcprevsolidtoken.tokencode == TBaseType.rrw_with)) {
                    lcprevsolidtoken.tokencode = TBaseType.rrw_sqlserver_check_with;
                }
            } else if (ast.tokencode == TBaseType.rrw_sqlserver_next) {
                TSourceToken st1 = ast.nextSolidToken();
                if ((st1 != null) && (st1.tokencode == '.')) {
                    ast.tokencode = TBaseType.ident;
                }
            } else if (ast.tokencode == TBaseType.rrw_fetch) {
                if ((lcprevsolidtoken != null) && ((lcprevsolidtoken.tokencode == TBaseType.rrw_sqlserver_row) || (lcprevsolidtoken.tokencode == TBaseType.rrw_sqlserver_rows))) {
                    TSourceToken prev2 = lcprevsolidtoken.searchToken(TBaseType.rrw_open, -1);
                    if (prev2 == null) {
                        ast.tokencode = TBaseType.rrw_sqlserver_offset_fetch;
                    }
                }
            } else if ((ast.tokencode == TBaseType.rrw_exec) || (ast.tokencode == TBaseType.rrw_execute)) {
                // search ;2 after execute
                // EXECUTE ApxSQL_Test_Triggers_Add;2  @TableName, @AddFlag
                int searchRange = 4;
                TSourceToken endTokenInSameLine = ast.searchTokenAtTheEndOfSameLine();
                if (endTokenInSameLine != null) {
                    searchRange = endTokenInSameLine.posinlist - ast.posinlist;
                }
                TSourceToken st1 = ast.searchToken(';', searchRange);
                if (st1 != null) {
                    TSourceToken numSt = st1.nextSolidToken();
                    if ((numSt != null) && (numSt.tokentype == ETokenType.ttnumber)) {
                        st1.tokencode = TBaseType.rrw_sqlserver_semicolon_module_number;
                        st1.tokentype = ETokenType.ttidentifier;
                    }
                }
            } else if (ast.tokencode == TBaseType.rrw_sqlserver_trim) {
                TSourceToken st1 = ast.nextSolidToken();
                if (st1 != null) {
                    if (st1.tokencode == '(') {
                        // keep as trim keyword
                    } else {
                        ast.tokencode = TBaseType.ident;
                    }
                }
            }

            if (gst == EFindSqlStateType.ststoredprocedurebody) {
                if (!((ast.tokencode == TBaseType.rrw_go)
                        || (ast.tokencode == TBaseType.rrw_create)
                        || (ast.tokencode == TBaseType.rrw_alter))) {
                    gcurrentsqlstatement.sourcetokenlist.add(ast);
                    continue;
                }
            }

            TCustomSqlStatement lcnextsqlstatement = sqlcmds.issql(ast, gst, gcurrentsqlstatement);

            switch (gst) {
                case sterror: {
                    if (TBaseType.assigned(lcnextsqlstatement)) {
                        onRawStatementComplete(parserContext, gcurrentsqlstatement, fparser, null, sqlstatements, false, builder);
                        gcurrentsqlstatement = lcnextsqlstatement;
                        gcurrentsqlstatement.sourcetokenlist.add(ast);
                        gst = EFindSqlStateType.stsql;
                    } else if ((ast.tokentype == ETokenType.ttsemicolon)) {
                        gcurrentsqlstatement.sourcetokenlist.add(ast);
                        onRawStatementComplete(parserContext, gcurrentsqlstatement, fparser, null, sqlstatements, false, builder);
                        gst = EFindSqlStateType.stnormal;
                    } else {
                        gcurrentsqlstatement.sourcetokenlist.add(ast);
                    }
                    break;
                }
                case stnormal: {
                    if ((ast.tokencode == TBaseType.cmtdoublehyphen)
                            || (ast.tokencode == TBaseType.cmtslashstar)
                            || (ast.tokencode == TBaseType.lexspace)
                            || (ast.tokencode == TBaseType.lexnewline)
                            || (ast.tokentype == ETokenType.ttsemicolon)) {
                        if (TBaseType.assigned(gcurrentsqlstatement)) {
                            gcurrentsqlstatement.sourcetokenlist.add(ast);
                        }

                        if (TBaseType.assigned(lcprevsolidtoken) && (ast.tokentype == ETokenType.ttsemicolon)) {
                            if (lcprevsolidtoken.tokentype == ETokenType.ttsemicolon) {
                                // ;;;; continuous semicolon,treat it as comment
                                ast.tokentype = ETokenType.ttsimplecomment;
                                ast.tokencode = TBaseType.cmtdoublehyphen;
                            }
                        }

                        continue;
                    }

                    gcurrentsqlstatement = lcnextsqlstatement;

                    if (TBaseType.assigned(gcurrentsqlstatement)) {
                        switch (gcurrentsqlstatement.sqlstatementtype) {
                            case sstmssqlcreateprocedure:
                            case sstmssqlcreatefunction:
                            case sstcreatetrigger:
                            case sstmssqlalterprocedure:
                            case sstmssqlalterfunction:
                            case sstmssqlaltertrigger: {
                                gcurrentsqlstatement.sourcetokenlist.add(ast);
                                gst = EFindSqlStateType.ststoredprocedure;
                                break;
                            }
                            case sstmssqlbegintry:
                            case sstmssqlbegincatch: {
                                gcurrentsqlstatement.sourcetokenlist.add(ast);
                                gst = EFindSqlStateType.sttrycatch;
                                lctrycatchlevel = 0;
                                break;
                            }
                            case sstmssqlgo: {
                                gcurrentsqlstatement.sourcetokenlist.add(ast);
                                onRawStatementComplete(parserContext, gcurrentsqlstatement, fparser, null, sqlstatements, false, builder);
                                gst = EFindSqlStateType.stnormal;
                                break;
                            }
                            default: {
                                gcurrentsqlstatement.sourcetokenlist.add(ast);
                                gst = EFindSqlStateType.stsql;
                                break;
                            }
                        }
                    } else {
                        if (ast.tokencode == TBaseType.rrw_begin) {
                            gcurrentsqlstatement = new TMssqlBlock(vendor);
                            gcurrentsqlstatement.sqlstatementtype = ESqlStatementType.sstmssqlblock;
                            gcurrentsqlstatement.sourcetokenlist.add(ast);
                            gst = EFindSqlStateType.stblock;
                        } else {
                            if (sqlstatements.size() == 0) {
                                //first statement of mssql batch, treat it as exec sp
                                gst = EFindSqlStateType.stsql;
                                gcurrentsqlstatement = new TMssqlExecute(vendor);
                                gcurrentsqlstatement.sourcetokenlist.add(ast);
                            } else if (sqlstatements.get(sqlstatements.size() - 1).sqlstatementtype == ESqlStatementType.sstmssqlgo) {
                                // prev sql is go, treat it as exec sp
                                gst = EFindSqlStateType.stsql;
                                gcurrentsqlstatement = new TMssqlExecute(vendor);
                                gcurrentsqlstatement.sourcetokenlist.add(ast);
                            }
                        }
                    }

                    if (!TBaseType.assigned(gcurrentsqlstatement)) //error tokentext found
                    {
                        this.syntaxErrors.add(new TSyntaxError(ast.getAstext(), ast.lineNo, (ast.columnNo < 0 ? 0 : ast.columnNo)
                                , "Error when tokenlize", EErrorType.spwarning, TBaseType.MSG_WARNING_ERROR_WHEN_TOKENIZE, null, ast.posinlist));

                        ast.tokentype = ETokenType.tttokenlizererrortoken;
                        gst = EFindSqlStateType.sterror;

                        gcurrentsqlstatement = new TUnknownSqlStatement(vendor);
                        gcurrentsqlstatement.sqlstatementtype = ESqlStatementType.sstinvalid;
                        gcurrentsqlstatement.sourcetokenlist.add(ast);
                    }
                    break;
                }
                case stblock: {
                    if (TBaseType.assigned(lcnextsqlstatement)) {
                        if (lcnextsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlgo) {
                            onRawStatementComplete(parserContext, gcurrentsqlstatement, fparser, null, sqlstatements, false, builder);
                            gcurrentsqlstatement = lcnextsqlstatement;
                            gcurrentsqlstatement.sourcetokenlist.add(ast);
                            onRawStatementComplete(parserContext, gcurrentsqlstatement, fparser, null, sqlstatements, false, builder);
                            gst = EFindSqlStateType.stnormal;
                        } else {
                            lcnextsqlstatement = null;
                        }
                    }

                    if (gst == EFindSqlStateType.stblock) {
                        gcurrentsqlstatement.sourcetokenlist.add(ast);
                        if (ast.tokencode == TBaseType.rrw_begin) {
                            lcnextsolidtoken = sourcetokenlist.nextsolidtoken(i, 1, false);
                            if (TBaseType.assigned(lcnextsolidtoken)) {
                                if (!((lcnextsolidtoken.tokencode == TBaseType.rrw_sqlserver_tran)
                                        || (lcnextsolidtoken.tokencode == TBaseType.rrw_sqlserver_transaction)
                                        || (lcnextsolidtoken.tokencode == TBaseType.rrw_sqlserver_distributed)
                                        || (lcnextsolidtoken.tokencode == TBaseType.rrw_sqlserver_dialog)
                                        || (lcnextsolidtoken.tokencode == TBaseType.rrw_sqlserver_conversation)
                                ))
                                    lcblocklevel++;
                            } else
                                lcblocklevel++;

                        } else if (ast.tokencode == TBaseType.rrw_case)
                            lcblocklevel++;
                        else if (ast.tokencode == TBaseType.rrw_end) {

                            lcisendconversation = false;

                            lcnextsolidtoken = sourcetokenlist.nextsolidtoken(i, 1, false);
                            if (TBaseType.assigned(lcnextsolidtoken)) {
                                if (lcnextsolidtoken.tokencode == TBaseType.rrw_sqlserver_conversation)
                                    lcisendconversation = true;
                            }

                            if (!lcisendconversation) {

                                if (lcblocklevel == 0) {
                                    if (gcurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlif) {
                                        if (TBaseType.assigned(lcnextsolidtoken)) {
                                            if (lcnextsolidtoken.tokencode == TBaseType.rrw_else) {
                                                gst = EFindSqlStateType.stsql;
                                            } else if (lcnextsolidtoken.tokentype == ETokenType.ttsemicolon) {
                                                lcnnextsolidtoken = sourcetokenlist.nextsolidtoken(lcnextsolidtoken.posinlist, 1, false);
                                                if (TBaseType.assigned(lcnnextsolidtoken)) {
                                                    if (lcnnextsolidtoken.tokencode == TBaseType.rrw_else) {
                                                        gst = EFindSqlStateType.stsql;
                                                    }
                                                }
                                            }
                                        }
                                    }

                                    if (gst != EFindSqlStateType.stsql) {
                                        onRawStatementComplete(parserContext, gcurrentsqlstatement, fparser, null, sqlstatements, false, builder);
                                        gst = EFindSqlStateType.stnormal;
                                    }

                                } else {
                                    lcblocklevel--;
                                }

                            }
                        }
                    }
                    break;
                }
                case sttrycatch: {

                    if (TBaseType.assigned(lcnextsqlstatement)) {
                        if (lcnextsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlgo) {
                            onRawStatementComplete(parserContext, gcurrentsqlstatement, fparser, null, sqlstatements, false, builder);
                            gcurrentsqlstatement = lcnextsqlstatement;
                            gcurrentsqlstatement.sourcetokenlist.add(ast);
                            onRawStatementComplete(parserContext, gcurrentsqlstatement, fparser, null, sqlstatements, false, builder);
                            gst = EFindSqlStateType.stnormal;
                        } else {
                            if (
                                    (lcnextsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlbegintry)
                                            || (lcnextsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlbegincatch)
                            )
                                lctrycatchlevel++;
                            lcnextsqlstatement = null;
                        }
                    }

                    if (gst == EFindSqlStateType.sttrycatch) {
                        gcurrentsqlstatement.sourcetokenlist.add(ast);
                        if ((ast.tokencode == TBaseType.rrw_try) ||
                                (ast.tokencode == TBaseType.rrw_catch)) {
                            if (TBaseType.assigned(lcprevsolidtoken)) {
                                if (lcprevsolidtoken.tokencode == TBaseType.rrw_end) {
                                    if (lctrycatchlevel == 0) {
                                        onRawStatementComplete(parserContext, gcurrentsqlstatement, fparser, null, sqlstatements, false, builder);
                                        gst = EFindSqlStateType.stnormal;
                                    } else
                                        lctrycatchlevel--;
                                }
                            }
                        }
                    }
                    break;
                }
                case stprocedureWithReturn: {
                    // found return statement in create procedure/function

                    if (TBaseType.assigned(lcnextsqlstatement)) {
                        if (lcnextsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlgo) {
                            onRawStatementComplete(parserContext, gcurrentsqlstatement, fparser, null, sqlstatements, false, builder);
                            gcurrentsqlstatement = lcnextsqlstatement;
                            gcurrentsqlstatement.sourcetokenlist.add(ast);
                            onRawStatementComplete(parserContext, gcurrentsqlstatement, fparser, null, sqlstatements, false, builder);
                            gst = EFindSqlStateType.stnormal;
                            break;
                        }
                    }

                    gcurrentsqlstatement.sourcetokenlist.add(ast);
                    if ((gst == EFindSqlStateType.stprocedureWithReturn) && (ast.tokentype == ETokenType.ttsemicolon)) {
                        onRawStatementComplete(parserContext, gcurrentsqlstatement, fparser, null, sqlstatements, false, builder);
                        gst = EFindSqlStateType.stnormal;
                    }
                    break;
                }
                case stsql: {
                    if ((ast.tokentype == ETokenType.ttsemicolon)) {
                        lcstillinsql = false;
                        if (gcurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlif) {
                            lcnextsolidtoken = sourcetokenlist.nextsolidtoken(i, 1, false);
                            if (TBaseType.assigned(lcnextsolidtoken)) {
                                if (lcnextsolidtoken.tokencode == TBaseType.rrw_else) {
                                    // if ( expr stmt; else
                                    gcurrentsqlstatement.sourcetokenlist.add(ast);
                                    lcstillinsql = true;
                                }

                            }
                        }

                        if (!lcstillinsql) {
                            gst = EFindSqlStateType.stnormal;
                            gcurrentsqlstatement.sourcetokenlist.add(ast);
                            gcurrentsqlstatement.semicolonended = ast;
                            onRawStatementComplete(parserContext, gcurrentsqlstatement, fparser, null, sqlstatements, false, builder);
                        }

                    } else if (TBaseType.assigned(lcnextsqlstatement)) {

                        if (lcnextsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlgo) {
                            onRawStatementComplete(parserContext, gcurrentsqlstatement, fparser, null, sqlstatements, false, builder);
                            gcurrentsqlstatement = lcnextsqlstatement;
                            gcurrentsqlstatement.sourcetokenlist.add(ast);
                            onRawStatementComplete(parserContext, gcurrentsqlstatement, fparser, null, sqlstatements, false, builder);
                            gst = EFindSqlStateType.stnormal;
                            continue;
                        }

                        switch (gcurrentsqlstatement.sqlstatementtype) {
                            case sstmssqlif:
                            case sstmssqlwhile: {
                                if ((lcnextsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlbegincatch)
                                        || (lcnextsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlbegintry)) {
                                    gcurrentsqlstatement.sourcetokenlist.add(ast);
                                    gst = EFindSqlStateType.stblock;
                                    lcblocklevel = 1;
                                    lcnextsqlstatement = null;
                                    continue;

                                } else if (gcurrentsqlstatement.dummytag == 1) {
                                    // if ( cond ^stmt nextstmt (^ stands for current pos)
                                    gcurrentsqlstatement.sourcetokenlist.add(ast);

                                    if ((lcnextsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlif)
                                            || (lcnextsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlwhile))
                                        gcurrentsqlstatement.dummytag = 1;
                                    else
                                        gcurrentsqlstatement.dummytag = 0;

                                    lcnextsqlstatement = null;
                                    continue;
                                } else {
                                    if (lcnextsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlif) {
                                        if ((ast.nextSolidToken() != null) && (ast.nextSolidToken().tokencode == TBaseType.rrw_sqlserver_exists)) {
                                            gcurrentsqlstatement.sourcetokenlist.add(ast);
                                            lcnextsqlstatement = null;
                                            continue;
                                        }
                                    }
                                }
                                break;
                            }
                            case sstmssqlalterqueue: {
                                if (lcnextsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlexec) {
                                    // execute can't be used to delimite alter queue
                                    gcurrentsqlstatement.sourcetokenlist.add(ast);
                                    lcnextsqlstatement = null;
                                    continue;

                                }
                                break;
                            }
                            case sstmssqlcreateschema: {
                                gcurrentsqlstatement.sourcetokenlist.add(ast);
                                lcnextsqlstatement = null;
                                continue;
                            }
                        }

                        onRawStatementComplete(parserContext, gcurrentsqlstatement, fparser, null, sqlstatements, false, builder);
                        gcurrentsqlstatement = lcnextsqlstatement;
                        gcurrentsqlstatement.sourcetokenlist.add(ast);

                        switch (gcurrentsqlstatement.sqlstatementtype) {
                            case sstmssqlcreateprocedure:
                            case sstmssqlcreatefunction:
                            case sstcreatetrigger:
                            case sstmssqlalterprocedure:
                            case sstmssqlalterfunction:
                            case sstmssqlaltertrigger: {
                                gst = EFindSqlStateType.ststoredprocedure;
                                break;
                            }
                            case sstmssqlbegintry:
                            case sstmssqlbegincatch: {
                                gst = EFindSqlStateType.sttrycatch;
                                lctrycatchlevel = 0;
                                break;
                            }
                            case sstmssqlgo: {
                                gst = EFindSqlStateType.stnormal;
                                break;
                            }
                            default: {
                                gst = EFindSqlStateType.stsql;
                                break;
                            }
                        }

                    } else if ((ast.tokencode == TBaseType.rrw_begin)) {
                        if ((gcurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlif)
                                || (gcurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlwhile)) {
                            gst = EFindSqlStateType.stblock;
                            lcblocklevel = 0;
                            gcurrentsqlstatement.sourcetokenlist.add(ast);
                        } else if (gcurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqldeclare) {
                            onRawStatementComplete(parserContext, gcurrentsqlstatement, fparser, null, sqlstatements, false, builder);
                            gcurrentsqlstatement = new TMssqlBlock(vendor);
                            gcurrentsqlstatement.sqlstatementtype = ESqlStatementType.sstmssqlblock;
                            gcurrentsqlstatement.sourcetokenlist.add(ast);
                            gst = EFindSqlStateType.stblock;
                        } else {
                            gcurrentsqlstatement.sourcetokenlist.add(ast);
                        }
                    } else if ((ast.tokencode == TBaseType.rrw_case)) {
                        case_end_nest++;
                        gcurrentsqlstatement.sourcetokenlist.add(ast);
                    } else if ((ast.tokencode == TBaseType.rrw_end)) {
                        if (case_end_nest > 0) {
                            case_end_nest--;
                        }
                        gcurrentsqlstatement.sourcetokenlist.add(ast);
                    } else if ((ast.tokencode == TBaseType.rrw_else)) {
                        gcurrentsqlstatement.sourcetokenlist.add(ast);
                        if (((gcurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlif)
                                || (gcurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlwhile)
                        ) && (case_end_nest == 0))
                            gcurrentsqlstatement.dummytag = 1;
                    } else {
                        gcurrentsqlstatement.sourcetokenlist.add(ast);
                    }
                    break;
                }
                case ststoredprocedure: {
                    if (TBaseType.assigned(lcnextsqlstatement)) {
                        if (lcnextsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlgo) {
                            onRawStatementComplete(parserContext, gcurrentsqlstatement, fparser, null, sqlstatements, false, builder);
                            gcurrentsqlstatement = lcnextsqlstatement;
                            gcurrentsqlstatement.sourcetokenlist.add(ast);
                            onRawStatementComplete(parserContext, gcurrentsqlstatement, fparser, null, sqlstatements, false, builder);
                            gst = EFindSqlStateType.stnormal;
                        } else if (lcnextsqlstatement.sqlstatementtype == sstmssqlreturn) {
                            gst = EFindSqlStateType.stprocedureWithReturn;
                            gcurrentsqlstatement.sourcetokenlist.add(ast);
                            lcnextsqlstatement = null;
                        } else {
                            gst = EFindSqlStateType.ststoredprocedurebody;
                            gcurrentsqlstatement.sourcetokenlist.add(ast);

                            lcnextsqlstatement = null;
                        }
                    }

                    if (gst == EFindSqlStateType.ststoredprocedure) {
                        gcurrentsqlstatement.sourcetokenlist.add(ast);
                        if (ast.tokencode == TBaseType.rrw_begin) {
                            gst = EFindSqlStateType.stblock;
                        }
                    }
                    break;
                }
                case ststoredprocedurebody: {
                    if (TBaseType.assigned(lcnextsqlstatement)) {
                        switch (lcnextsqlstatement.sqlstatementtype) {
                            case sstmssqlgo: {
                                onRawStatementComplete(parserContext, gcurrentsqlstatement, fparser, null, sqlstatements, false, builder);
                                gcurrentsqlstatement = lcnextsqlstatement;
                                gcurrentsqlstatement.sourcetokenlist.add(ast);
                                onRawStatementComplete(parserContext, gcurrentsqlstatement, fparser, null, sqlstatements, false, builder);
                                gst = EFindSqlStateType.stnormal;
                                break;
                            }
                            case sstmssqlcreateprocedure:
                            case sstmssqlcreatefunction:
                            case sstcreatetrigger:
                            case sstmssqlalterprocedure:
                            case sstmssqlalterfunction:
                            case sstmssqlaltertrigger: {
                                onRawStatementComplete(parserContext, gcurrentsqlstatement, fparser, null, sqlstatements, false, builder);
                                gcurrentsqlstatement = lcnextsqlstatement;
                                gcurrentsqlstatement.sourcetokenlist.add(ast);
                                gst = EFindSqlStateType.ststoredprocedure;
                                break;
                            }
                            case sstcreateview:
                            case sstcreatetable: {

                                boolean readForNewStmt = false;
                                TSourceToken st1 = ast.searchToken(';', -1);
                                if (st1 != null) {
                                    TSourceToken st2 = ast.searchToken(TBaseType.rrw_end, -2);
                                    if (st2 != null) {
                                        readForNewStmt = true;
                                    }
                                }

                                if (readForNewStmt) {
                                    onRawStatementComplete(parserContext, gcurrentsqlstatement, fparser, null, sqlstatements, false, builder);
                                    gcurrentsqlstatement = lcnextsqlstatement;
                                    gcurrentsqlstatement.sourcetokenlist.add(ast);
                                    gst = EFindSqlStateType.stsql;
                                } else {
                                    lcnextsqlstatement = null;
                                }
                                break;
                            }
                            case sstmssqlDropSecurityPolicy:
                            case sstmssqlAlterSecurityPolicy:
                            case sstmssqlCreateSecurityPolicy:
                                onRawStatementComplete(parserContext, gcurrentsqlstatement, fparser, null, sqlstatements, false, builder);
                                gcurrentsqlstatement = lcnextsqlstatement;
                                gcurrentsqlstatement.sourcetokenlist.add(ast);
                                gst = EFindSqlStateType.stsql;

                                break;
                            default: {
                                lcnextsqlstatement = null;
                                break;
                            }
                        }
                    }

                    if (gst == EFindSqlStateType.ststoredprocedurebody)
                        gcurrentsqlstatement.sourcetokenlist.add(ast);
                }
                break;
            }
        }

        //last statement
        if (TBaseType.assigned(gcurrentsqlstatement) && (gst != EFindSqlStateType.stnormal)) {
            onRawStatementComplete(parserContext, gcurrentsqlstatement, fparser, null, sqlstatements, true, builder);
        }

        // Set results in builder
        builder.sqlStatements(this.sqlstatements);
        builder.errorCode(errorcount);
        builder.errorMessage(errorcount == 0 ? "" : String.format("Extraction completed with %d error(s)", errorcount));
    }
}