package gudusoft.gsqlparser.parser;

import gudusoft.gsqlparser.EDbVendor;
import gudusoft.gsqlparser.TBaseType;
import gudusoft.gsqlparser.TGSqlParser;
import gudusoft.gsqlparser.TCustomLexer;
import gudusoft.gsqlparser.TCustomParser;
import gudusoft.gsqlparser.TCustomSqlStatement;
import gudusoft.gsqlparser.TLexerMssql;
import gudusoft.gsqlparser.TParserMssqlSql;
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.resolver2.TSQLResolver2;
import gudusoft.gsqlparser.resolver2.TSQLResolverConfig;
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;

/**
 * Microsoft SQL Server database SQL parser implementation.
 *
 * <p>This parser handles SQL Server-specific SQL syntax including:
 * <ul>
 *   <li>T-SQL blocks (stored procedures, functions, triggers)</li>
 *   <li>BEGIN/END blocks</li>
 *   <li>TRY/CATCH error handling</li>
 *   <li>GO batch separator</li>
 *   <li>SQL Server-specific DML/DDL (MERGE, OPENROWSET, etc.)</li>
 *   <li>Special token handling (LOCK TABLE, COPY INTO, etc.)</li>
 * </ul>
 *
 * <p><b>Design Notes:</b>
 * <ul>
 *   <li>Extends {@link AbstractSqlParser} using the template method pattern</li>
 *   <li>Uses {@link TLexerMssql} for tokenization</li>
 *   <li>Uses {@link TParserMssqlSql} for parsing</li>
 *   <li>Delimiter character: ';' for SQL statements</li>
 * </ul>
 *
 * <p><b>Usage Example:</b>
 * <pre>
 * // Get SQL Server parser from factory
 * SqlParser parser = SqlParserFactory.get(EDbVendor.dbvmssql);
 *
 * // Build context
 * ParserContext context = new ParserContext.Builder(EDbVendor.dbvmssql)
 *     .sqlText("SELECT * FROM Employees WHERE DepartmentID = 10")
 *     .build();
 *
 * // Parse
 * SqlParseResult result = parser.parse(context);
 *
 * // Access statements
 * TStatementList statements = result.getSqlStatements();
 * </pre>
 *
 * @see SqlParser
 * @see AbstractSqlParser
 * @see TLexerMssql
 * @see TParserMssqlSql
 * @since 3.2.0.0
 */
public class MssqlSqlParser extends AbstractSqlParser {

    /**
     * Construct SQL Server SQL parser.
     * <p>
     * Configures the parser for SQL Server 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 MssqlSqlParser() {
        super(EDbVendor.dbvmssql);
        this.delimiterChar = ';';
        this.defaultDelimiterStr = ";";

        // Create lexer once - will be reused for all parsing operations
        this.flexer = new TLexerMssql();
        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 TParserMssqlSql(null);
        this.fparser.lexer = this.flexer;
    }

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

    /** The SQL Server lexer used for tokenization */
    public TLexerMssql flexer;

    /** SQL parser (for SQL Server statements) */
    private TParserMssqlSql 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 SQL Server lexer instance.
     */
    @Override
    protected TCustomLexer getLexer(ParserContext context) {
        return this.flexer;
    }

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

    /**
     * Call MSSQL-specific tokenization logic.
     * <p>
     * Delegates to domssqlsqltexttotokenlist which handles SQL Server's
     * specific keyword recognition, bracket identifiers, and token generation.
     */
    @Override
    protected void tokenizeVendorSql() {
        domssqlsqltexttotokenlist();
    }

    /**
     * Setup MSSQL parser for raw statement extraction.
     * <p>
     * MSSQL 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 MSSQL-specific raw statement extraction logic.
     * <p>
     * Delegates to domssqlgetrawsqlstatements which handles SQL Server's
     * statement delimiters (semicolon and GO command).
     */
    @Override
    protected void extractVendorRawStatements(SqlParseResult.Builder builder) {
        domssqlgetrawsqlstatements(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 = (TParserMssqlSql) parser;
        this.sourcetokenlist = tokens;
        this.parserContext = context;

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

        // Initialize statement parsing infrastructure. Use the context vendor
        // so delegated dialects (e.g. dbvexasol) get their own cmds resolver.
        this.sqlcmds = SqlCmdsFactory.get(context != null ? context.getVendor() : vendor);

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

        // Initialize global context for semantic analysis
        // CRITICAL: When delegated from TGSqlParser, use TGSqlParser's frameStack
        // so that variables set in SET statements can be found by EXECUTE statements
        if (context != null && context.getGsqlparser() != null) {
            TGSqlParser gsqlparser = (TGSqlParser) context.getGsqlparser();
            this.frameStack = gsqlparser.getFrameStack();

            // CRITICAL: Set gsqlparser on the NodeFactory - matches TGSqlParser behavior
            // This is needed for proper AST node creation during parsing
            this.fparser.getNf().setGsqlParser(gsqlparser);

            // Create global context if needed
            this.globalContext = new TContext();
            this.sqlEnv = new TSQLEnv(this.vendor) {
                @Override
                public void initSQLEnv() {
                }
            };
            this.globalContext.setSqlEnv(this.sqlEnv, this.sqlstatements);
        } else {
            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
               // ex.printStackTrace();
                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 MSSQL

    /**
     * Exasol pre-pass: the Exasol dialect shares this parser, and its extra
     * syntax is keyed on synthetic tokens (TBaseType.rrw_exasol_*) that the
     * MSSQL lexer never emits. When the requested dialect is dbvexasol, this
     * pass rewrites the Exasol-only words to those token codes (and hides a
     * few tokens the shared grammar cannot carry, e.g. OR REPLACE after
     * CREATE). Real T-SQL input never reaches the Exasol grammar rules.
     */
    @Override
    protected void processTokensBeforeParse(ParserContext context, TSourceTokenList tokens) {
        super.processTokensBeforeParse(context, tokens);
        if (context != null && context.getVendor() == EDbVendor.dbvmssql
                && context.isMssqlColonBindVariablesEnabled()) {
            mergeMssqlColonBindVariables(tokens);
        }
        if (context == null || context.getVendor() != EDbVendor.dbvexasol) {
            return;
        }
        boolean stmtHasInvalid = false;
        TSourceToken stmtFirst = null;
        TSourceToken prevSolid = null;
        for (int i = 0; i < tokens.size(); i++) {
            TSourceToken st = tokens.get(i);
            if (st.tokentype == ETokenType.ttwhitespace || st.tokentype == ETokenType.ttreturn
                    || st.tokentype == ETokenType.ttsimplecomment || st.tokentype == ETokenType.ttbracketedcomment) {
                continue;
            }
            if (st.tokentype == ETokenType.ttsemicolon) {
                stmtHasInvalid = false;
                stmtFirst = null;
                prevSolid = null;
                continue;
            }
            if (stmtFirst == null) {
                stmtFirst = st;
            }
            TSourceToken next = st.nextSolidToken();
            if (st.tokentype == ETokenType.ttidentifier || st.tokentype == ETokenType.ttkeyword) {
                // CREATE OR REPLACE <obj>: hide OR REPLACE (T-SQL grammar has
                // CREATE [OR ALTER] only; Exasol semantics identical for parse).
                if (st.tokencode == TBaseType.rrw_or && prevSolid == stmtFirst
                        && wordIs(stmtFirst, "create") && wordIs(next, "replace")) {
                    hideToken(st);
                    hideToken(next);
                    continue;
                }
                // (EXPLAIN VIRTUAL <select>) as a derived table: hide the
                // EXPLAIN VIRTUAL introducer so the inner select parses as a
                // plain subquery.
                if (wordIs(st, "explain")
                        && prevSolid != null && prevSolid.tokentype == ETokenType.ttleftparenthesis
                        && wordIs(next, "virtual")) {
                    hideToken(st);
                    hideToken(next);
                    continue;
                }
                if (wordIs(st, "qualify") && st.tokentype == ETokenType.ttidentifier) {
                    st.tokencode = TBaseType.rrw_exasol_qualify;
                } else if (wordIs(st, "limit") && st.tokentype == ETokenType.ttidentifier) {
                    st.tokencode = TBaseType.rrw_mssql_limit;
                } else if (wordIs(st, "invalid") && st.tokentype == ETokenType.ttidentifier
                        && startsVerificationKind(next)) {
                    st.tokencode = TBaseType.rrw_exasol_invalid;
                    stmtHasInvalid = true;
                    // hide an optional preceding WITH (SELECT cols WITH INVALID ...)
                    if (prevSolid != null && prevSolid.tokencode == TBaseType.rrw_with) {
                        hideToken(prevSolid);
                    }
                } else if (wordIs(st, "referencing") && st.tokentype == ETokenType.ttidentifier && stmtHasInvalid) {
                    st.tokencode = TBaseType.rrw_exasol_referencing;
                } else if (wordIs(st, "distribute") && next != null && next.tokencode == TBaseType.rrw_by) {
                    st.tokencode = TBaseType.rrw_exasol_distribute;
                } else if (wordIs(st, "distribution") && prevSolid != null
                        && prevSolid.tokencode == TBaseType.rrw_drop && wordIs(next, "keys")) {
                    st.tokencode = TBaseType.rrw_exasol_distribute;
                } else if (wordIs(st, "including")
                        && (wordIs(next, "defaults") || wordIs(next, "identity") || wordIs(next, "comments"))) {
                    st.tokencode = TBaseType.rrw_exasol_including;
                } else if (st.tokencode == TBaseType.rrw_mssql_partition
                        && next != null && next.tokencode == TBaseType.rrw_by
                        && prevSolid != null && prevSolid.tokentype == ETokenType.ttcomma
                        && (wordIs(stmtFirst, "create") || wordIs(stmtFirst, "alter"))) {
                    // PARTITION BY as a CREATE/ALTER TABLE element (never after
                    // '(' — that is a window function's OVER(PARTITION BY ...)).
                    st.tokencode = TBaseType.rrw_exasol_partition;
                } else if (st.tokencode == TBaseType.rrw_mssql_prior
                        && (prevSolid == null || prevSolid.tokencode != TBaseType.rrw_fetch)) {
                    st.tokencode = TBaseType.rrw_exasol_prior;
                } else if ((wordIs(st, "disable") || wordIs(st, "enable"))
                        && prevSolid != null && prevSolid.tokentype == ETokenType.ttrightparenthesis) {
                    // constraint state after REFERENCES t (cols)
                    st.tokencode = TBaseType.rrw_exasol_disable;
                } else if (wordIs(st, "admin") && st.tokentype == ETokenType.ttidentifier
                        && prevSolid != null && prevSolid.tokencode == TBaseType.rrw_with
                        && wordIs(next, "option")) {
                    st.tokencode = TBaseType.rrw_mssql_admin;
                } else if (wordIs(st, "access") && st.tokentype == ETokenType.ttidentifier
                        && (wordIs(stmtFirst, "grant") || wordIs(stmtFirst, "revoke"))
                        && wordIs(next, "on")) {
                    st.tokencode = TBaseType.rrw_mssql_access;
                }
            }
            prevSolid = st;
        }
    }

    /**
     * Merge client-style colon placeholders after ordinary SQL Server
     * tokenization. Keeping this opt-in transformation out of the lexer leaves
     * the default token stream, including token coordinates, byte-for-byte
     * compatible with earlier releases.
     */
    private void mergeMssqlColonBindVariables(TSourceTokenList tokens) {
        for (int i = 0; i + 1 < tokens.size(); i++) {
            TSourceToken colon = tokens.get(i);
            TSourceToken suffix = tokens.get(i + 1);
            if (colon.tokenstatus == ETokenStatus.tsdeleted
                    || suffix.tokenstatus == ETokenStatus.tsdeleted
                    || colon.tokencode != ':'
                    || colon.offset + colon.getAstext().length() != suffix.offset
                    || !isMssqlColonBindSuffix(suffix.getAstext())) {
                continue;
            }
            colon.setString(colon.getAstext() + suffix.getAstext());
            colon.tokencode = TBaseType.bind_v;
            colon.tokentype = ETokenType.ttbindvar;
            suffix.tokenstatus = ETokenStatus.tsdeleted;
        }
    }

    private boolean isMssqlColonBindSuffix(String text) {
        if (text == null || text.isEmpty()) {
            return false;
        }
        int start = text.charAt(0) == '@' ? 1 : 0;
        if (start == text.length()) {
            return false;
        }
        for (int i = start; i < text.length(); i++) {
            char ch = text.charAt(i);
            if (!(ch == '_' || ch >= 'A' && ch <= 'Z'
                    || ch >= 'a' && ch <= 'z' || ch >= '0' && ch <= '9')) {
                return false;
            }
        }
        return true;
    }

    private static boolean startsVerificationKind(TSourceToken t) {
        if (t == null) return false;
        TSourceToken t2 = t.nextSolidToken();
        if (wordIs(t, "unique")) {
            return t2 != null && t2.tokentype == ETokenType.ttleftparenthesis;
        }
        if (wordIs(t, "primary") || wordIs(t, "foreign")) {
            TSourceToken t3 = t2 == null ? null : t2.nextSolidToken();
            return wordIs(t2, "key") && t3 != null && t3.tokentype == ETokenType.ttleftparenthesis;
        }
        return false;
    }

    /** Case-insensitive command-word comparison (keywords, not identifiers). */
    private static boolean wordIs(TSourceToken t, String w) {
        return t != null && t.toString().equalsIgnoreCase(w);
    }

    /**
     * True when the routine collected so far is a CLR routine, i.e. its body is
     * {@code AS EXTERNAL NAME assembly.class.method} rather than a BEGIN...END
     * block. Such a statement ends at its semicolon; there is no body to wait for.
     */
    private static boolean hasExternalNameBody(TCustomSqlStatement stmt) {
        if (stmt == null) return false;
        TSourceTokenList tokens = stmt.sourcetokenlist;
        if (tokens == null) return false;
        TSourceToken prevSolid = null;
        for (int i = 0; i < tokens.size(); i++) {
            TSourceToken t = tokens.get(i);
            if (t.isnonsolidtoken()) continue;
            // non-identifier-compare: keyword text. The splitter runs before the
            // vendor parser, so the vendor-specific RW_EXTERNAL / RW_AS token codes
            // are not available here; NAME reaches the grammar as a plain ColId.
            if (wordIs(t, "external") && wordIs(prevSolid, "as")) {
                return wordIs(t.nextSolidToken(), "name");
            }
            prevSolid = t;
        }
        return false;
    }

    /** Neutralize a token for both the splitter and the parser. */
    private static void hideToken(TSourceToken t) {
        t.tokentype = ETokenType.ttsimplecomment;
        t.tokencode = TBaseType.cmtdoublehyphen;
    }

    /**
     * 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 SQL Server-specific semantic analysis.
     * <p>
     * When called via delegation from TGSqlParser (context.getGsqlparser() != null),
     * semantic analysis is skipped here and handled by TGSqlParser.doDelegatedParse()
     * to ensure resolver2 is stored in TGSqlParser where tests expect to find it.
     * <p>
     * When called directly on MssqlSqlParser, uses TBaseType flags to determine
     * which resolver to use:
     * <ul>
     *   <li>TBaseType.isEnableResolver2() -> use TSQLResolver2</li>
     *   <li>TBaseType.isEnableResolver() -> use TSQLResolver</li>
     * </ul>
     */
    @Override
    protected void performSemanticAnalysis(ParserContext context, TStatementList statements) {
        // Skip semantic analysis when delegated from TGSqlParser
        // TGSqlParser.doDelegatedParse() will handle it to store resolver2 properly
        if (context != null && context.getGsqlparser() != null) {
            return;
        }

        if (getSyntaxErrors().isEmpty()) {
            if (TBaseType.isEnableResolver2()) {
                // Use TSQLResolver2
                TSQLResolverConfig config = new TSQLResolverConfig();
                config.setVendor(vendor);
                TSQLResolver2 resolver2 = new TSQLResolver2(null, statements, config);
                if (this.sqlEnv != null) {
                    resolver2.setSqlEnv(this.sqlEnv);
                }
                resolver2.resolve();
            } else if (TBaseType.isEnableResolver()) {
                // Use TSQLResolver
                TSQLResolver resolver = new TSQLResolver(globalContext, statements);
                resolver.resolve();
            }
            // If neither resolver is enabled, skip semantic analysis
        }
    }

    /**
     * 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();
        }
    }

    // ========== SQL Server-Specific Tokenization ==========

    /**
     * SQL Server-specific tokenization logic.
     * <p>
     * Extracted from: TGSqlParser.domssqlsqltexttotokenlist() (lines 2225-2425)
     */
    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.
     * <p>
     * Matches TGSqlParser.getprevtoken() implementation exactly to ensure
     * consistent tokenization behavior.
     */
    private TSourceToken getprevtoken(TSourceToken ptoken) {
        TSourceTokenList lcstlist = ptoken.container;
        if (TBaseType.assigned(lcstlist)) {
            if ((ptoken.posinlist > 0) && (lcstlist.size() > ptoken.posinlist - 1)) {
                if (!((lcstlist.get(ptoken.posinlist - 1).tokentype == ETokenType.ttwhitespace)
                        || (lcstlist.get(ptoken.posinlist - 1).tokentype == ETokenType.ttreturn)
                        || (lcstlist.get(ptoken.posinlist - 1).tokentype == ETokenType.ttsimplecomment)
                        || (lcstlist.get(ptoken.posinlist - 1).tokentype == ETokenType.ttbracketedcomment)
                )) {
                    return lcstlist.get(ptoken.posinlist - 1);
                } else {
                    return lcstlist.nextsolidtoken(ptoken.posinlist - 1, -1, false);
                }
            }
        }
        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).
     * <p>
     * Extracted from: TGSqlParser.checkconstarinttoken() (lines 1989-2005)
     *
     * @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;
                }
            }
        }
    }

    // ========== SQL Server-Specific Raw Statement Extraction ==========

    /**
     * SQL Server-specific raw statement extraction logic.
     * <p>
     * Extracted from: TGSqlParser.domssqlgetrawsqlstatements() (lines 13081-13904)
     */
    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;
                } else if ((st1 != null) && TBaseType.mycomparetext(st1.getAstext(), "PATH") == 0) {
                    ast.tokencode = TBaseType.rw_for_path;
                }
            }

            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.ident && ast.tokentype == ETokenType.ttdbstring) {
                // Handle bracket-quoted XML method names: .[value](), .[nodes](), etc.
                if ((lcprevsolidtoken != null) && (lcprevsolidtoken.tokencode == '.')) {
                    TSourceToken st1 = ast.searchToken('(', 1);
                    if (st1 != null) {
                        String text = ast.toString();
                        if (text.length() > 2) {
                            String inner = text.substring(1, text.length() - 1).toLowerCase();
                            if (inner.equals("value")) {
                                ast.tokencode = TBaseType.rrw_xml_value;
                            } else if (inner.equals("modify")) {
                                ast.tokencode = TBaseType.rrw_xml_modify;
                            } else if (inner.equals("query")) {
                                ast.tokencode = TBaseType.rrw_xml_query;
                            } else if (inner.equals("exist")) {
                                ast.tokencode = TBaseType.rrw_xml_exist;
                            } else if (inner.equals("nodes")) {
                                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 (vendor == EDbVendor.dbvopenedge){
                if (ast.tokencode == TBaseType.rrw_order){
                        TSourceToken st1 = ast.searchToken(TBaseType.rrw_by,1);
                        if (st1 == null) {
                            ast.tokencode = TBaseType.ident;
                        }
                }else if (ast.tokencode == TBaseType.rrw_with){
                        TSourceToken st1 = ast.searchToken(TBaseType.rrw_check,1);
                        if (st1 != null) {
                            ast.tokencode = TBaseType.rrw_openedge_with_check;
                        }
                }
            }

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

                        // A typed TUnknownSqlStatement (admin DDL recognized by
                        // the splitter, no deep AST) has no internal statement
                        // structure: it runs to its semicolon. Without this,
                        // ALTER EXTERNAL LANGUAGE ... SET (...) split at SET
                        // because SET is a registered statement head.
                        if ((gcurrentsqlstatement instanceof gudusoft.gsqlparser.stmt.TUnknownSqlStatement)
                                && (gcurrentsqlstatement.sqlstatementtype != ESqlStatementType.sstinvalid)
                                && (gcurrentsqlstatement.sqlstatementtype != ESqlStatementType.sstunknown)) {
                            gcurrentsqlstatement.sourcetokenlist.add(ast);
                            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;
                            }
                        }

                        // "IF EXISTS <name>" belongs to the statement it
                        // follows (DROP DEFAULT d IF EXISTS ...). But
                        // "IF EXISTS (SELECT ...)" is control flow starting a
                        // new statement - real scripts chain unterminated
                        // statements before it - so the '(' after EXISTS
                        // decides.
                        if (lcnextsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlif) {
                            TSourceToken existsTok = ast.nextSolidToken();
                            if ((existsTok != null)
                                    && (existsTok.tokencode == TBaseType.rrw_sqlserver_exists)) {
                                TSourceToken afterExists = existsTok.nextSolidToken();
                                if ((afterExists == null)
                                        || (afterExists.tokentype != ETokenType.ttleftparenthesis)) {
                                    gcurrentsqlstatement.sourcetokenlist.add(ast);
                                    continue;
                                }
                            }
                        }

                        // ALTER PARTITION FUNCTION f() MERGE|SPLIT RANGE (...):
                        // the MERGE keyword is the function operation, not a
                        // MERGE statement.
                        if ((gcurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstmssqlAlterPartitionFunction)
                                && (lcnextsqlstatement.sqlstatementtype == ESqlStatementType.sstmerge)) {
                            gcurrentsqlstatement.sourcetokenlist.add(ast);
                            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 (case_end_nest > 0) {
                            // Inside a CASE expression — BEGIN cannot be a top-level block boundary
                            gcurrentsqlstatement.sourcetokenlist.add(ast);
                        } else {
                            // mantisbt 4411: a plain BEGIN ... END after a complete statement
                            // (EXEC, SELECT, UPDATE, SET, DECLARE, PRINT, RAISERROR, label, ...)
                            // starts a new top-level TMssqlBlock. Previously the else branch
                            // silently swallowed BEGIN into the preceding statement, breaking
                            // the parse for batches like:
                            //   EXEC dbo.p1
                            //   BEGIN UPDATE x SET y = 1 END
                            onRawStatementComplete(parserContext, gcurrentsqlstatement, fparser, null, sqlstatements, false, builder);
                            gcurrentsqlstatement = new TMssqlBlock(vendor);
                            gcurrentsqlstatement.sqlstatementtype = ESqlStatementType.sstmssqlblock;
                            gcurrentsqlstatement.sourcetokenlist.add(ast);
                            gst = EFindSqlStateType.stblock;
                        }
                    } 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;
                        } else if ((ast.tokentype == ETokenType.ttsemicolon)
                                && hasExternalNameBody(gcurrentsqlstatement)) {
                            // CLR routine: AS EXTERNAL NAME assembly.class.method has no
                            // BEGIN...END body, so the semicolon ends the statement. Without
                            // this the splitter keeps waiting for a body and swallows the
                            // next statement of the script.
                            onRawStatementComplete(parserContext, gcurrentsqlstatement, fparser, null, sqlstatements, false, builder);
                            gst = EFindSqlStateType.stnormal;
                        }
                    }
                    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) {
                                        // Verify this END is at block level 0 (not inside a nested
                                        // BEGIN...END or BEGIN TRY...END TRY block) by counting
                                        // BEGINs and ENDs in the current proc's token list.
                                        int blockDepth = 0;
                                        for (int k = 0; k < gcurrentsqlstatement.sourcetokenlist.size(); k++) {
                                            TSourceToken tk = gcurrentsqlstatement.sourcetokenlist.get(k);
                                            if (tk.tokencode == TBaseType.rrw_begin) {
                                                TSourceToken tkNext = tk.nextSolidToken();
                                                if (tkNext == null || (tkNext.tokencode != TBaseType.rrw_sqlserver_tran
                                                        && tkNext.tokencode != TBaseType.rrw_sqlserver_transaction
                                                        && tkNext.tokencode != TBaseType.rrw_sqlserver_distributed
                                                        && tkNext.tokencode != TBaseType.rrw_sqlserver_dialog
                                                        && tkNext.tokencode != TBaseType.rrw_sqlserver_conversation)) {
                                                    blockDepth++;
                                                }
                                            } else if (tk.tokencode == TBaseType.rrw_end) {
                                                TSourceToken tkNext = tk.nextSolidToken();
                                                if (tkNext == null || tkNext.tokencode != TBaseType.rrw_sqlserver_conversation) {
                                                    blockDepth--;
                                                }
                                            }
                                        }
                                        // blockDepth == 0 means all BEGIN/END pairs are balanced
                                        // so the END; is at the top level (proc boundary)
                                        if (blockDepth == 0) {
                                            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));
    }
}