/*
 * Decompiled with CFR 0.152.
 */
package gudusoft.gsqlparser.parser;

import gudusoft.gsqlparser.EDataType;
import gudusoft.gsqlparser.EDbVendor;
import gudusoft.gsqlparser.EErrorType;
import gudusoft.gsqlparser.EFindSqlStateType;
import gudusoft.gsqlparser.ESqlStatementType;
import gudusoft.gsqlparser.ETokenType;
import gudusoft.gsqlparser.TBaseType;
import gudusoft.gsqlparser.TCustomLexer;
import gudusoft.gsqlparser.TCustomParser;
import gudusoft.gsqlparser.TCustomSqlStatement;
import gudusoft.gsqlparser.TLexerTeradata;
import gudusoft.gsqlparser.TParserTeradata;
import gudusoft.gsqlparser.TSourceToken;
import gudusoft.gsqlparser.TSourceTokenList;
import gudusoft.gsqlparser.TStatementList;
import gudusoft.gsqlparser.TSyntaxError;
import gudusoft.gsqlparser.nodes.TDatatypeAttribute;
import gudusoft.gsqlparser.nodes.TFunctionCall;
import gudusoft.gsqlparser.nodes.TTypeName;
import gudusoft.gsqlparser.nodes.teradata.TTeradataHelper;
import gudusoft.gsqlparser.parser.AbstractSqlParser;
import gudusoft.gsqlparser.parser.ParserContext;
import gudusoft.gsqlparser.parser.SqlParseResult;
import gudusoft.gsqlparser.resolver.TSQLResolver;
import gudusoft.gsqlparser.sqlcmds.SqlCmdsFactory;
import gudusoft.gsqlparser.stmt.TUnknownSqlStatement;
import gudusoft.gsqlparser.stmt.teradata.TTeradataBTEQCmd;
import gudusoft.gsqlparser.stmt.teradata.TTeradataFastExportCmd;
import gudusoft.gsqlparser.stmt.teradata.TTeradataFastLoadCmd;
import gudusoft.gsqlparser.stmt.teradata.TTeradataMultiLoadCmd;
import gudusoft.gsqlparser.stmt.teradata.utilities.BteqCmdType;
import java.util.ArrayList;

public class TeradataSqlParser
extends AbstractSqlParser {
    public TLexerTeradata flexer;
    private TParserTeradata fparser;
    private TCustomSqlStatement gcurrentsqlstatement;
    private char curdelimiterchar = (char)59;

    // BTEQ state tracking - must persist across token processing
    private boolean inBTEQComment = false;
    private boolean isContinueBTEQCmd = false;
    // Track when we're collecting a SQL statement after .IF/.ELSEIF THEN
    private boolean isInIfThenStatement = false;

    public TeradataSqlParser() {
        super(EDbVendor.dbvteradata);
        this.delimiterChar = '/';  // Teradata uses forward slash as delimiter for stored procedures
        this.defaultDelimiterStr = ";";  // Match TGSqlParser default
        this.flexer = new TLexerTeradata();
        this.flexer.delimiterchar = '/';  // Must match TGSqlParser: delimiterchar = '/'
        this.flexer.defaultDelimiterStr = ";";  // Match TGSqlParser default
        this.lexer = this.flexer;
        this.fparser = new TParserTeradata(null);
        this.fparser.lexer = this.flexer;
    }

    @Override
    protected TCustomLexer getLexer(ParserContext context) {
        // Transfer Teradata utility type from context to lexer
        if (context.getTeradataUtilityType() != null) {
            this.flexer.setTeradataUtilityType(context.getTeradataUtilityType());
        }
        return this.flexer;
    }

    @Override
    protected TCustomParser getParser(ParserContext context, TSourceTokenList tokens) {
        this.fparser.sourcetokenlist = tokens;
        return this.fparser;
    }

    @Override
    protected TCustomParser getSecondaryParser(ParserContext context, TSourceTokenList tokens) {
        return null;
    }

    @Override
    protected void tokenizeVendorSql() {
        this.doteradatatexttotokenlist();
    }

    @Override
    protected void setupVendorParsersForExtraction() {
        this.fparser.sqlcmds = this.sqlcmds;
        this.fparser.sourcetokenlist = this.sourcetokenlist;
    }

    @Override
    protected void extractVendorRawStatements(SqlParseResult.Builder builder) {
        this.doteradatagetrawsqlstatements(builder);
    }

    private void doteradatatexttotokenlist() {
        TSourceToken asourcetoken, lcprevst;
        int yychar;

        asourcetoken = this.getanewsourcetoken();
        if (asourcetoken == null) {
            return;
        }
        yychar = asourcetoken.tokencode;

        while (yychar > 0) {
            this.sourcetokenlist.add(asourcetoken);
            asourcetoken = this.getanewsourcetoken();
            if (asourcetoken == null) break;

            if ((asourcetoken.tokencode == TBaseType.rrw_casespecific)
                    || (asourcetoken.tokencode == TBaseType.rrw_teradata_cs)) {
                // change not to not1 to make "not null column constraints" work correctly
                // |RW_NOT1 RW_CASESPECIFIC
                lcprevst = this.getprevsolidtoken(asourcetoken);
                if (lcprevst != null) {
                    if (lcprevst.tokencode == TBaseType.rrw_not) {
                        lcprevst.tokencode = TBaseType.rw_not1;
                    }
                }
            } else if (asourcetoken.tokencode == ';') {
                lcprevst = this.getprevsolidtoken(asourcetoken);
                if (lcprevst != null) {
                    if (lcprevst.tokencode == ';') {
                        asourcetoken.tokencode = TBaseType.sqlpluscmd;
                    }
                }
            } else if (asourcetoken.tokencode == TBaseType.variable) { // mantisbt/view.php?id=972
                if (asourcetoken.toString().toLowerCase().endsWith("begin")) { // MYPROC :BEGIN
                    asourcetoken.tokencode = TBaseType.rrw_begin;
                    asourcetoken.tokentype = ETokenType.ttkeyword;

                    lcprevst = this.getprevsolidtoken(asourcetoken);
                    if (lcprevst != null) {
                        lcprevst.tokencode = TBaseType.mslabel;
                    }
                }
            } else if (asourcetoken.tokencode == TCustomLexer.UNICODE_ENCODE_ID) {
                if (asourcetoken.toString().endsWith("008D")) { // REVERSE LINE FEED, https://codepoints.net/U+008D?lang=en
                    asourcetoken.tokencode = TBaseType.lexspace;
                } else {
                    asourcetoken.tokencode = TBaseType.ident;
                }
            }

            yychar = asourcetoken.tokencode;
        }
    }

    private TSourceToken getprevsolidtoken(TSourceToken ptoken) {
        TSourceToken ret = null;
        TSourceTokenList lctokenlist = ptoken.container;
        if (lctokenlist != null && ptoken.posinlist > 0 && lctokenlist.size() > ptoken.posinlist - 1) {
            ret = lctokenlist.get((int)(ptoken.posinlist - 1)).tokentype != ETokenType.ttwhitespace && lctokenlist.get((int)(ptoken.posinlist - 1)).tokentype != ETokenType.ttreturn && lctokenlist.get((int)(ptoken.posinlist - 1)).tokentype != ETokenType.ttsimplecomment && lctokenlist.get((int)(ptoken.posinlist - 1)).tokentype != ETokenType.ttbracketedcomment ? lctokenlist.get(ptoken.posinlist - 1) : lctokenlist.nextsolidtoken(ptoken.posinlist - 1, -1, false);
        }
        return ret;
    }

    private int doteradatagetrawsqlstatements(SqlParseResult.Builder builder) {
        this.gcurrentsqlstatement = null;
        EFindSqlStateType gst = EFindSqlStateType.stnormal;
        int lcNestedParens = 0;
        int lcNestedBeginEnd = 0;
        int lcNestedCase = 0;
        int lcNestedSample = 0;
        Object lcprevst = null;
        Object lcnextst = null;
        Object lcnextst2 = null;
        Object lcnextst3 = null;
        TSourceToken lcprevsolidtoken = null;
        TSourceToken ast = null;
        int errorcount = 0;
        // Note: inBTEQComment, isContinueBTEQCmd, isInIfThenStatement are instance fields
        this.inBTEQComment = false;
        this.isContinueBTEQCmd = false;
        this.isInIfThenStatement = false;
        char ch;
        String lcstr;
        block10: for (int i = 0; i < this.sourcetokenlist.size(); ++i) {
            if (ast != null && ast.issolidtoken()) {
                lcprevsolidtoken = ast;
            }
            ast = this.sourcetokenlist.get(i);
            this.sourcetokenlist.curpos = i;
            if (ast.tokencode != TBaseType.rrw_time && ast.tokencode != TBaseType.rrw_date && ast.tokencode != TBaseType.rrw_timestamp) {
                if (ast.tokencode == '(') {
                    this.handleLeftParenthesisToken(ast, i);
                } else if (ast.tokencode == TBaseType.rrw_for) {
                    this.handleForToken(ast);
                } else if (ast.tokencode == TBaseType.rrw_teradata_last) {
                    this.handleLastToken(ast);
                } else if (ast.tokencode == TBaseType.rrw_teradata_pivot) {
                    this.handlePivotToken(ast);
                } else if (ast.tokencode == TBaseType.rrw_teradata_period) {
                    this.handlePeriodToken(ast);
                } else if (ast.tokencode == TBaseType.rrw_teradata_transaction) {
                    this.handleTransactionToken(ast);
                } else if (ast.tokencode == TBaseType.rrw_replace) {
                    this.handleReplaceToken(ast);
                } else if (ast.tokencode == TBaseType.rrw_between) {
                    this.handleBetweenToken(ast);
                } else if (ast.tokencode == TBaseType.rrw_declare) {
                    this.handleDeclareToken(ast);
                } else if (ast.tokencode == TBaseType.rrw_case && ast.tag == 0 && ast.posinlist + 1 < this.sourcetokenlist.size()) {
                    this.handleCaseToken(ast);
                } else if (ast.tokencode == TBaseType.rrw_grant) {
                    this.handleGrantToken(ast);
                } else if (ast.tokencode == TBaseType.variable) {
                    this.handleVariableToken(ast);
                } else if (ast.tokencode == TBaseType.rrw_teradata_sequenced || ast.tokencode == TBaseType.rrw_teradata_nonsequenced) {
                    this.handleSequencedToken(ast);
                }
            }
            switch (gst) {
                case sterror: {
                    if (ast.tokentype == ETokenType.ttsemicolon) {
                        this.gcurrentsqlstatement.sourcetokenlist.add(ast);
                        this.onRawStatementComplete(this.parserContext, this.gcurrentsqlstatement, this.fparser, null, this.sqlstatements, false, builder);
                        gst = EFindSqlStateType.stnormal;
                        continue block10;
                    }
                    this.gcurrentsqlstatement.sourcetokenlist.add(ast);
                    continue block10;
                }
                case stMultiLoadCmd: {
                    gst = this.handleMultiLoadCmdState(ast, gst, builder);
                    continue block10;
                }
                case stFastExportCmd: {
                    gst = this.handleFastExportCmdState(ast, gst, builder);
                    continue block10;
                }
                case stFastLoadCmd: {
                    gst = this.handleFastLoadCmdState(ast, gst, builder);
                    continue block10;
                }
                case stBTEQCmd: {
                    gst = this.handleBTEQCmdState(ast, builder);
                    continue block10;
                }
                case stnormal: {
                    gst = this.handleNormalState(ast, gst, lcprevsolidtoken, builder);
                    if (gst != EFindSqlStateType.ststoredprocedure) continue block10;
                    lcNestedParens = 0;
                    continue block10;
                }
                case stsql: {
                    boolean readyToEnd = true;
                    if (this.gcurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstteradatacreatemacro) {
                        if (ast.tokencode == '(' || ast.tokencode == TBaseType.left_parenthesis_2) {
                            ++lcNestedParens;
                        }
                        if (ast.tokencode == ')') {
                            --lcNestedParens;
                            if (lcNestedParens < 0) {
                                lcNestedParens = 0;
                            }
                        }
                        readyToEnd = lcNestedParens == 0;
                    }
                    if (ast.tokentype == ETokenType.ttsemicolon && readyToEnd) {
                        this.gcurrentsqlstatement.sourcetokenlist.add(ast);
                        this.gcurrentsqlstatement.semicolonended = ast;
                        this.onRawStatementComplete(this.parserContext, this.gcurrentsqlstatement, this.fparser, null, this.sqlstatements, false, builder);
                        gst = EFindSqlStateType.stnormal;
                        continue block10;
                    }
                    if (ast.tokencode == TBaseType.cmtdoublehyphen && ast.toString().trim().endsWith(TBaseType.sqlflow_stmt_delimiter_str)) {
                        this.onRawStatementComplete(this.parserContext, this.gcurrentsqlstatement, this.fparser, null, this.sqlstatements, false, builder);
                        gst = EFindSqlStateType.stnormal;
                        continue block10;
                    }
                    this.gcurrentsqlstatement.sourcetokenlist.add(ast);
                    continue block10;
                }
                case ststoredprocedure: {
                    boolean readyToEnd = true;
                    if (ast.tokencode == ';') {
                        // don't count case..end, sample ... end after ;
                        lcNestedSample = 0;
                        lcNestedCase = 0;
                    } else if (ast.tokencode == TBaseType.rrw_case) { // case ... end
                        ++lcNestedCase;
                        TSourceToken prevst = ast.prevSolidToken();
                        if (prevst != null && prevst.tokencode == TBaseType.rrw_end) {
                            // don't count: end case
                            --lcNestedCase;
                        }
                    } else if (ast.tokencode == TBaseType.rrw_teradata_sample) { // sample ... end
                        ++lcNestedSample;
                    }
                    if (this.gcurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstcreatetrigger
                            || this.gcurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstcreateprocedure
                            || this.gcurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstcreatefunction) {
                        if (ast.tokencode == '(' || ast.tokencode == TBaseType.left_parenthesis_2) {
                            ++lcNestedParens;
                        }
                        if (ast.tokencode == ')' && --lcNestedParens < 0) {
                            lcNestedParens = 0;
                        }
                        if (ast.tokencode == TBaseType.rrw_begin) {
                            ++lcNestedBeginEnd;
                        }
                        if (ast.tokencode == TBaseType.rrw_end) {
                            boolean countThisEnd = true;
                            if (lcNestedSample > 0) {
                                // don't count sample...end
                                --lcNestedSample;
                                countThisEnd = false;
                            } else if (lcNestedCase > 0) {
                                // don't count case...end
                                --lcNestedCase;
                                countThisEnd = false;
                            }
                            if (countThisEnd) {
                                // don't count end while/if/case/loop/for/repeat
                                TSourceToken nt = ast.nextSolidToken();
                                if (nt != null) {
                                    countThisEnd = nt.tokencode != TBaseType.rrw_while
                                            && nt.tokencode != TBaseType.rrw_if
                                            && nt.tokencode != TBaseType.rrw_case
                                            && nt.tokencode != TBaseType.rrw_loop
                                            && nt.tokencode != TBaseType.rrw_for
                                            && nt.tokencode != TBaseType.rrw_repeat;
                                }
                            }
                            if (countThisEnd && --lcNestedBeginEnd < 0) {
                                lcNestedBeginEnd = 0;
                            }
                        }
                        readyToEnd = lcNestedParens == 0 && lcNestedBeginEnd == 0;
                    }
                    // single stmt in function/procedure/trigger may use ; as terminate char
                    // so default terminate char is ;, if begin is found, then
                    // set terminate char to DelimiterChar
                    if (this.curdelimiterchar != this.delimiterChar) {
                        if (ast.tokencode == TBaseType.rrw_begin) {
                            this.curdelimiterchar = this.delimiterChar;
                        } else if (ast.tokencode == TBaseType.mslabel && ast.container.nextsolidtoken(ast, 1, false).tokencode == TBaseType.rrw_begin) {
                            this.curdelimiterchar = this.delimiterChar;
                        }
                    }
                    if (this.curdelimiterchar == ';') {
                        this.gcurrentsqlstatement.sourcetokenlist.add(ast);
                        if (ast.tokentype == ETokenType.ttsemicolon
                                && (this.gcurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstcreatetrigger
                                    || this.gcurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstcreateprocedure)
                                && readyToEnd) {
                            gst = EFindSqlStateType.stnormal;
                            this.gcurrentsqlstatement.semicolonended = ast;
                            this.onRawStatementComplete(this.parserContext, this.gcurrentsqlstatement, this.fparser, null, this.sqlstatements, false, builder);
                            continue block10;
                        }
                    } else {
                        if (ast.getAstext().length() == 1) {
                            ch = ast.getAstext().charAt(0);
                        } else if (ast.getAstext().length() > 1) {
                            ch = ast.getAstext().charAt(ast.getAstext().length() - 1);
                        } else {
                            ch = ' ';
                        }
                        if (ast.tokencode != TBaseType.cmtslashstar && ast.tokencode != TBaseType.cmtdoublehyphen
                                && ch == this.curdelimiterchar && ast.isFirstTokenOfLine() && readyToEnd) {
                            if (ast.getAstext().length() > 1) {
                                lcstr = ast.getAstext().substring(0, ast.getAstext().length() - 1);
                                int c2 = this.flexer.getkeywordvalue(lcstr);
                                if (c2 > 0) {
                                    ast.tokencode = c2;
                                }
                            } else {
                                this.gcurrentsqlstatement.semicolonended = ast;
                            }
                            this.gcurrentsqlstatement.sourcetokenlist.add(ast);
                            gst = EFindSqlStateType.stnormal;
                            this.onRawStatementComplete(this.parserContext, this.gcurrentsqlstatement, this.fparser, null, this.sqlstatements, false, builder);
                        } else if (ast.searchToken(TBaseType.rrw_create, 1) != null && ast.searchToken(TBaseType.rrw_procedure, 4) != null && readyToEnd) {
                            gst = EFindSqlStateType.stnormal;
                            this.onRawStatementComplete(this.parserContext, this.gcurrentsqlstatement, this.fparser, null, this.sqlstatements, false, builder);
                        } else if (ast.tokencode == ';') {
                            this.gcurrentsqlstatement.sourcetokenlist.add(ast);
                            boolean startNewStatement = false;
                            if (readyToEnd) {
                                startNewStatement = this.sqlcmds.issql(ast.nextSolidToken(), gst, this.gcurrentsqlstatement) != null;
                            }
                            if (startNewStatement) {
                                gst = EFindSqlStateType.stnormal;
                                this.onRawStatementComplete(this.parserContext, this.gcurrentsqlstatement, this.fparser, null, this.sqlstatements, false, builder);
                            }
                        } else {
                            this.gcurrentsqlstatement.sourcetokenlist.add(ast);
                        }
                    }
                    if (gst == EFindSqlStateType.ststoredprocedure && ast.tokencode == TBaseType.cmtdoublehyphen && ast.toString().trim().endsWith(TBaseType.sqlflow_stmt_delimiter_str)) {
                        gst = EFindSqlStateType.stnormal;
                        this.onRawStatementComplete(this.parserContext, this.gcurrentsqlstatement, this.fparser, null, this.sqlstatements, false, builder);
                    }
                }
            }
        }
        if (TBaseType.assigned(this.gcurrentsqlstatement) && (gst == EFindSqlStateType.stsql || gst == EFindSqlStateType.stBTEQCmd || gst == EFindSqlStateType.ststoredprocedure || gst == EFindSqlStateType.sterror
                || gst == EFindSqlStateType.stFastExportCmd || gst == EFindSqlStateType.stFastLoadCmd || gst == EFindSqlStateType.stMultiLoadCmd)) {
            this.onRawStatementComplete(this.parserContext, this.gcurrentsqlstatement, this.fparser, null, this.sqlstatements, true, builder);
        }
        builder.sqlStatements(this.sqlstatements);
        builder.syntaxErrors(this.syntaxErrors instanceof ArrayList ? (ArrayList)this.syntaxErrors : new ArrayList(this.syntaxErrors));
        builder.errorCode(this.syntaxErrors.isEmpty() ? 0 : this.syntaxErrors.size());
        return errorcount;
    }

    private void handleLeftParenthesisToken(TSourceToken ast, int i) {
        TSourceToken lcnextst = this.sourcetokenlist.nextsolidtoken(i, 1, false);
        TSourceToken lcprevst = this.getprevsolidtoken(ast);
        if ((lcprevst != null) && (
                (lcprevst.tokencode == TBaseType.rrw_teradata_cast)
                || (lcprevst.tokencode == TBaseType.rrw_year) // sample sql: select year(date) - 1 mantisbt/view.php?id=3049
        )) {
            lcnextst = null; // don't check next token if prev token is cast. sample: cast(DATETIME as BIGINT)
        }
        if ((lcprevst != null) && (TFunctionCall.isBuiltIn(lcprevst.toString(), EDbVendor.dbvteradata))) {
            if (((lcprevst.tokencode == TBaseType.rrw_end)
                    || (lcprevst.tokencode == TBaseType.rrw_time)
                    || (lcprevst.tokencode == TBaseType.rrw_date)
                    || (lcprevst.tokencode == TBaseType.rrw_timestamp)
                    || (lcprevst.tokencode == TBaseType.rrw_teradata_type)
                    || (lcprevst.toString().equalsIgnoreCase("current_date"))
                    || (lcprevst.toString().equalsIgnoreCase("current_time"))
                    || (lcprevst.toString().equalsIgnoreCase("current_timestamp"))
                    || (lcprevst.toString().equalsIgnoreCase("user"))
                    || (lcprevst.toString().equalsIgnoreCase("current_user"))
            )) {
                // Keep lcnextst as is
            } else {
                lcnextst = null;
            }
        }
        if (lcnextst != null) {
            EDataType dataType = TTypeName.searchTeradataTypeByName(lcnextst.toString());
            if ((dataType != null) && (lcprevst != null) && (lcprevst.tokencode != TBaseType.rrw_teradata_period)) {
                ast.tokencode = TBaseType.rrw_teradata_start_data_conversion;
                // lcnextst2 is the token 2 steps after (
                TSourceToken lcnextst2 = this.sourcetokenlist.nextsolidtoken(i, 2, false);
                // lcnextst3 is the token 3 steps after (
                TSourceToken lcnextst3 = this.sourcetokenlist.nextsolidtoken(i, 3, false);
                if (lcnextst2.tokencode == ',') {
                    // this is data conversion: (date,format '$xxx'),
                    // this is not data conversion: trunc(date,'yy')
                    TSourceToken st1 = lcnextst3;
                    TSourceToken st2 = this.sourcetokenlist.nextsolidtoken(i, 4, false);
                    if (TDatatypeAttribute.searchDataTypeAttributeByName(st1, st2) == null) {
                        // this is not data conversion, such as :trunc(date,'yy')
                        ast.tokencode = '(';
                    }
                } else if (lcnextst2 != null) {
                    // lcnextst3 may be null when (date) is at end of query
                    this.handleDataTypeConversion(ast, dataType, lcnextst2, lcnextst3, lcprevst);
                }
            } else {
                TSourceToken st1 = lcnextst;
                TSourceToken st2 = this.sourcetokenlist.nextsolidtoken(i, 2, false);
                if (TDatatypeAttribute.searchDataTypeAttributeByName(st1, st2) != null) {
                    ast.tokencode = TBaseType.rrw_teradata_start_data_conversion;
                }
            }
        }
    }

    private void handleDataTypeConversion(TSourceToken ast, EDataType dataType, TSourceToken lcnextst2, TSourceToken lcnextst3, TSourceToken lcprevst) {
        switch (dataType) {
            case date_t:
            case time_t:
                // next token is: ) or comma or data attribute token
                if ((lcnextst2.tokencode == ')')
                        || ((lcnextst2.tokencode == '(') && (lcnextst3 != null) && (lcnextst3.tokencode == TBaseType.iconst))) { // hire_date (time(6))
                    // (date)
                    // select (date) from t, here (date) is a function, not a data conversion,
                    // But if prev token is identifier like TD_WEDNESDAY (no space before parenthesis), treat as function call
                    // mantisbt/view.php?id=4023
                    // f3 (date) - with space - is data conversion
                    // TD_WEDNESDAY(date) - no space - is function call
                    if ((lcprevst != null) && (lcprevst.tokencode == TBaseType.ident) && (lcnextst2.tokencode == ')')) {
                        // Check if there's whitespace between identifier and '('
                        // If identifier ends at column X and '(' starts at column X+1, there's no space
                        long identEndCol = lcprevst.columnNo + lcprevst.toString().length();
                        if (identEndCol == ast.columnNo) {
                            // No space between identifier and '(' - treat as function call
                            ast.tokencode = '(';
                        }
                        // If there's a space, keep as DATA_CONVERSION for data conversion pattern
                    }
                } else {
                    ast.tokencode = '(';
                }
                break;
            case timestamp_t:
            case interval_t:
                if (lcnextst2.tokencode == TBaseType.sconst) { // INSERT t1 (TIME '10:44:25.123-08:00',TIMESTAMP '2000-09-20 10:44:25.1234')
                    ast.tokencode = '(';
                }
                break;
            case period_t:
                if (lcnextst2.tokencode == '(') {
                    // 只有 period() 才确保这里 period 是datatype，否则period不是datatype
                } else {
                    ast.tokencode = '(';
                }
                break;
            case char_t:
                if (lcnextst2.tokencode == ')') {
                    // NULL (CHAR) AS B
                } else if ((lcnextst3 == null) || (lcnextst3.tokencode != TBaseType.iconst)) { // INSERT t1 (TIME '10:44:25.123-08:00',TIMESTAMP '2000-09-20 10:44:25.1234')
                    ast.tokencode = '(';
                }
                break;
            default:
                break;
        }
    }

    private void handleForToken(TSourceToken ast) {
        TSourceToken nextToken = ast.searchTokenAfterObjectName();
        if (nextToken != null) {
            if (nextToken.tokencode == TBaseType.rrw_as) {
                ast.tokencode = TBaseType.rrw_teradata_for_loop;
            }
        }
    }

    private void handleLastToken(TSourceToken ast) {
        TSourceToken nextToken = ast.searchToken('(', 1);
        if (nextToken != null) {
            ast.tokencode = TBaseType.rrw_last_function;
        }
    }

    private void handlePivotToken(TSourceToken ast) {
        TSourceToken nextToken = ast.searchToken('(', 1);
        if (nextToken == null) {
            ast.tokencode = TBaseType.ident;
        }
    }

    private void handlePeriodToken(TSourceToken ast) {
        TSourceToken nextToken = ast.nextSolidToken();
        if (nextToken == null) {
            ast.tokencode = TBaseType.ident;
        } else if (nextToken.tokencode == '(') {
            // keep it as keyword
        } else if (nextToken.tokencode == TBaseType.rrw_for) {
            // keep it as keyword
        } else if (nextToken.tokencode == TBaseType.sconst) {
            // sample: DEFAULT PERIOD '(2005-02-03, 2006-02-03)'
            // keep it as keyword
        } else {
            if (ast.prevSolidToken() == null) {
                ast.tokencode = TBaseType.ident;
            } else {
                if (!ast.prevSolidToken().toString().equalsIgnoreCase("anchor")) {
                    ast.tokencode = TBaseType.ident;
                }
            }
        }
    }

    private void handleTransactionToken(TSourceToken ast) {
        TSourceToken lcprevst = this.getprevsolidtoken(ast);
        if (lcprevst != null) {
            if (lcprevst.tokencode == TBaseType.rrw_end) {
                lcprevst.tokencode = TBaseType.rrw_teradata_end_t;
            }
        }
    }

    private void handleReplaceToken(TSourceToken ast) {
        TSourceToken nextToken = ast.searchToken('(', 1);
        if (nextToken != null) {
            ast.tokencode = TBaseType.ident;
        }
    }

    private void handleBetweenToken(TSourceToken ast) {
        TSourceToken nextToken = ast.nextSolidToken();
        if (nextToken != null) {
            if ((nextToken.tokencode == TBaseType.rrw_begin) || (nextToken.tokencode == TBaseType.rrw_end)) {
                // BETWEEN begin(DODD_EFF_PERI)
                nextToken.tokencode = TBaseType.ident;
            }
        }
    }

    private void handleDeclareToken(TSourceToken ast) {
        TSourceToken nextToken = ast.nextSolidToken();
        if (nextToken != null) {
            TSourceToken nextnextToken = nextToken.nextSolidToken();
            if (nextnextToken != null) {
                if ((nextnextToken.toString().equalsIgnoreCase("cursor"))
                        || (nextnextToken.toString().equalsIgnoreCase("insensitive"))
                        || (nextnextToken.toString().equalsIgnoreCase("scroll"))
                        || (nextnextToken.toString().equalsIgnoreCase("no"))) {
                    nextToken.tokencode = TBaseType.rrw_teradata_cursor_name;
                } else if ((nextnextToken.toString().equalsIgnoreCase("condition"))) {
                    nextToken.tokencode = TBaseType.rrw_teradata_condition_name;
                }
            }
        }
    }

    private void handleCaseToken(TSourceToken ast) {
        int lcNest = 1;
        for (int m = ast.posinlist + 1; m < this.sourcetokenlist.size() - 1; m++) {
            TSourceToken st = this.sourcetokenlist.get(m);
            if (st.tokencode == TBaseType.rrw_case) {
                st.tag = 1; // this is nested case keyword, don't check this token later
                lcNest++;
            }
            if (st.tokencode == TBaseType.rrw_end) {
                lcNest--;
                if (lcNest == 0) {
                    TSourceToken caseToken = st.nextSolidToken();
                    if (caseToken != null) {
                        if (caseToken.tokencode == TBaseType.rrw_case) {
                            ast.tokencode = TBaseType.rrw_teradata_case_stmt;
                            caseToken.tag = 1; // this is case after end, don't check this token later
                        }
                    }
                    // Always break after finding the matching END, whether it's followed by CASE or not
                    // This prevents CASE expressions from incorrectly matching with later "END CASE" constructs
                    break;
                }
            }
        }
    }

    private void handleGrantToken(TSourceToken ast) {
        TSourceToken prevSolidToken = ast.prevSolidToken();
        if (prevSolidToken != null) {
            if (prevSolidToken.tokencode == TBaseType.rrw_with) {
                prevSolidToken.tokencode = TBaseType.rrw_teradata_with_grant;
            }
        }
    }

    private void handleVariableToken(TSourceToken ast) {
        // USING ( _spVV8 VARCHAR(1024) CHARACTER SET UNICODE ) SELECT INTO :_spVV8 ;
        // variable after into keyword treat as identifier
        TSourceToken prevSolidToken = ast.prevSolidToken();
        if (prevSolidToken != null) {
            if (prevSolidToken.tokencode == TBaseType.rrw_into) {
                ast.tokencode = TBaseType.ident;
            }
        }
    }

    private void handleSequencedToken(TSourceToken ast) {
        TSourceToken nextSolidToken = ast.nextSolidToken();
        if (nextSolidToken != null) {
            if ((nextSolidToken.tokencode == TBaseType.rrw_teradata_validtime)) {
                TSourceToken nextToken2 = nextSolidToken.nextSolidToken();
                if (nextToken2 != null) {
                    if ((nextToken2.tokencode == TBaseType.rrw_select)
                            || (nextToken2.tokencode == TBaseType.rrw_insert)
                            || (nextToken2.tokencode == TBaseType.rrw_update)
                            || (nextToken2.tokencode == TBaseType.rrw_delete)
                            || (nextToken2.tokencode == TBaseType.rrw_merge)) {
                        // SEQUENCED VALIDTIME select/insert/update/delete/merge
                        ast.tokencode = TBaseType.lexspace;
                        nextSolidToken.tokencode = TBaseType.lexspace;
                    }
                }
            }
        }
    }

    private EFindSqlStateType handleMultiLoadCmdState(TSourceToken ast, EFindSqlStateType gst, SqlParseResult.Builder builder) {
        this.gcurrentsqlstatement.sourcetokenlist.add(ast);
        if ((ast.tokencode == ';') && (ast.isLastTokenOfLine())) {
            TSourceToken nextToken = ast.nextSolidToken();
            TSourceToken nextToken2 = nextToken != null ? nextToken.nextSolidToken() : null;
            if (nextToken != null && nextToken2 != null &&
                    nextToken.tokencode == '.' &&
                    nextToken2.toString().equalsIgnoreCase("FIELD") &&
                    nextToken.isFirstTokenOfLine()) {
                // Remain in stMultiLoadCmd state
            } else {
                this.onRawStatementComplete(this.parserContext, this.gcurrentsqlstatement, this.fparser, null, this.sqlstatements, false, builder);
                gst = EFindSqlStateType.stnormal;
            }
        } else if (ast.isLastTokenOfLine()) {
            // .IF ERRORCODE <> 0 THEN
            // INSERT INTO Sou_EMP_Tab
            //        (1, 'bala');
            String cmdstr = this.gcurrentsqlstatement.sourcetokenlist.get(0).toString();
            if (this.gcurrentsqlstatement.sourcetokenlist.size() > 1) {
                cmdstr = cmdstr + this.gcurrentsqlstatement.sourcetokenlist.get(1).toString();
            }
            if ((cmdstr.toLowerCase().startsWith(".if")) || (cmdstr.toLowerCase().startsWith(".set")) || (cmdstr.toLowerCase().startsWith("set"))) {
                this.onRawStatementComplete(this.parserContext, this.gcurrentsqlstatement, this.fparser, null, this.sqlstatements, false, builder);
                gst = EFindSqlStateType.stnormal;
            }
        }
        return gst;
    }

    private EFindSqlStateType handleFastExportCmdState(TSourceToken ast, EFindSqlStateType gst, SqlParseResult.Builder builder) {
        this.gcurrentsqlstatement.sourcetokenlist.add(ast);
        if ((ast.tokencode == ';') && (ast.isLastTokenOfLine())) {
            this.onRawStatementComplete(this.parserContext, this.gcurrentsqlstatement, this.fparser, null, this.sqlstatements, false, builder);
            gst = EFindSqlStateType.stnormal;
        } else {
            boolean findSQL = false;
            TSourceToken nextst = ast.nextToken();
            if (nextst != null) {
                if (nextst.tokentype == ETokenType.ttreturn) {
                    findSQL = (this.sqlcmds.issql(ast.nextSolidToken(), gst, this.gcurrentsqlstatement) != null);
                    if (findSQL) {
                        this.onRawStatementComplete(this.parserContext, this.gcurrentsqlstatement, this.fparser, null, this.sqlstatements, false, builder);
                        gst = EFindSqlStateType.stnormal;
                    }
                }
            }
        }
        return gst;
    }

    private EFindSqlStateType handleFastLoadCmdState(TSourceToken ast, EFindSqlStateType gst, SqlParseResult.Builder builder) {
        this.gcurrentsqlstatement.sourcetokenlist.add(ast);
        if ((ast.tokencode == ';') && (ast.isLastTokenOfLine())) {
            this.onRawStatementComplete(this.parserContext, this.gcurrentsqlstatement, this.fparser, null, this.sqlstatements, false, builder);
            gst = EFindSqlStateType.stnormal;
        } else if (ast.tokencode == TBaseType.lexnewline) {
            TSourceToken nextst = ast.nextSolidToken();
            if (nextst != null) {
                if (nextst.tokencode == TBaseType.BTEQCMD) {
                    this.onRawStatementComplete(this.parserContext, this.gcurrentsqlstatement, this.fparser, null, this.sqlstatements, false, builder);
                    gst = EFindSqlStateType.stFastLoadCmd;
                } else if (nextst.tokencode == '.') {
                    this.onRawStatementComplete(this.parserContext, this.gcurrentsqlstatement, this.fparser, null, this.sqlstatements, false, builder);
                    gst = EFindSqlStateType.stFastLoadCmd;
                } else if (this.sqlcmds.issql(nextst, gst, this.gcurrentsqlstatement) != null) {
                    this.onRawStatementComplete(this.parserContext, this.gcurrentsqlstatement, this.fparser, null, this.sqlstatements, false, builder);
                    gst = EFindSqlStateType.stnormal;
                }
            }
        }
        return gst;
    }

    private EFindSqlStateType handleBTEQCmdState(TSourceToken ast, SqlParseResult.Builder builder) {
        EFindSqlStateType gst = EFindSqlStateType.stBTEQCmd;
        this.gcurrentsqlstatement.sourcetokenlist.add(ast);

        if (ast.tokencode == TBaseType.lexnewline) {
            if (this.isContinueBTEQCmd) {
                this.isContinueBTEQCmd = false;
            } else if (this.isInIfThenStatement) {
                // Continue collecting tokens for .IF/.ELSEIF THEN until semicolon
                // Don't complete the statement on newline
            } else {
                if (((TTeradataBTEQCmd)this.gcurrentsqlstatement).getBteqCmdType() == BteqCmdType.LOGON) {
                    boolean findSQL = (this.sqlcmds.issql(ast.nextSolidToken(), gst, this.gcurrentsqlstatement) != null);
                    if (findSQL) {
                        this.onRawStatementComplete(this.parserContext, this.gcurrentsqlstatement, this.fparser, null, this.sqlstatements, false, builder);
                        gst = EFindSqlStateType.stnormal;
                    }
                } else {
                    this.onRawStatementComplete(this.parserContext, this.gcurrentsqlstatement, this.fparser, null, this.sqlstatements, false, builder);
                    gst = EFindSqlStateType.stnormal;
                }
            }
        } else if ((ast.tokencode == '-') && (ast.isLastTokenOfLine())) {
            if (!this.inBTEQComment) {
                this.isContinueBTEQCmd = true;
            }
        } else if (ast.tokencode == TBaseType.lexspace) {
            // Do nothing
        } else if (ast.tokencode == ';') {
            // Reset IF THEN state when statement ends
            this.isInIfThenStatement = false;
            this.onRawStatementComplete(this.parserContext, this.gcurrentsqlstatement, this.fparser, null, this.sqlstatements, false, builder);
            boolean findNewCmdInSameLine = this.checkForNewBTEQCmdInSameLine(ast);
            if (findNewCmdInSameLine) {
                gst = EFindSqlStateType.stBTEQCmd;
            } else {
                gst = EFindSqlStateType.stnormal;
            }
        } else if (ast.tokencode == '*') {
            this.isContinueBTEQCmd = false;
        } else { // solid token
            // Check if this is a THEN keyword at end of line for .IF/.ELSEIF commands
            // In this case, the BTEQ command should continue to include the following SQL statement
            BteqCmdType cmdType = ((TTeradataBTEQCmd)this.gcurrentsqlstatement).getBteqCmdType();
            if ((cmdType == BteqCmdType.IF || cmdType == BteqCmdType.ELSEIF)
                && ast.tokencode == TBaseType.rrw_then
                && ast.isLastTokenOfLine()) {
                this.isContinueBTEQCmd = true;
                this.isInIfThenStatement = true;
            } else {
                this.isContinueBTEQCmd = false;
            }
        }
        return gst;
    }

    private boolean checkForNewBTEQCmdInSameLine(TSourceToken ast) {
        boolean findNewCmdInSameLine = false;
        if (!ast.isLastTokenOfLine()) {
            // check if next cmd like below:
            // .SET SIDETITLES ON; .SET FOLDLINE ON ALL
            TSourceToken nextst = ast.nextSolidToken();
            if ((nextst != null) && (nextst.tokencode == '.')) {
                TSourceToken nextst2 = nextst.nextSolidToken();
                TSourceToken searchToken = null;
                if (nextst2 != null) {
                    if (nextst2.tokencode == TBaseType.rrw_set) {
                        TSourceToken nextst3 = nextst2.nextSolidToken();
                        if (nextst3 != null) {
                            searchToken = nextst3;
                        }
                    } else {
                        searchToken = nextst2;
                    }

                    BteqCmdType bteqCmdType = BteqCmdType.searchBteqCmd(searchToken);
                    if (bteqCmdType != null) {
                        this.gcurrentsqlstatement = new TTeradataBTEQCmd(this.vendor);
                        ((TTeradataBTEQCmd)this.gcurrentsqlstatement).setBteqCmdType(bteqCmdType);
                        this.gcurrentsqlstatement.sourcetokenlist.add(ast);
                        findNewCmdInSameLine = true;
                    }
                }
            }
        }
        return findNewCmdInSameLine;
    }

    private EFindSqlStateType handleNormalState(TSourceToken ast, EFindSqlStateType gst, TSourceToken lcprevsolidtoken, SqlParseResult.Builder builder) {
        if ((ast.tokencode == TBaseType.cmtdoublehyphen)
                || (ast.tokencode == TBaseType.cmtslashstar)
                || (ast.tokencode == TBaseType.lexspace)
                || (ast.tokencode == TBaseType.lexnewline)
                || (ast.tokentype == ETokenType.ttsemicolon)) {
            if (TBaseType.assigned(this.gcurrentsqlstatement)) {
                this.gcurrentsqlstatement.sourcetokenlist.add(ast);
            }

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

            return gst;
        }
        if ((gst = this.checkForBTEQOrUtilityCommand(ast, gst)) != EFindSqlStateType.stnormal) {
            return gst;
        }

        // find a tokentext to start sql or stored procedure mode
        this.gcurrentsqlstatement = this.sqlcmds.issql(ast, gst, this.gcurrentsqlstatement);

        if (TBaseType.assigned(this.gcurrentsqlstatement)) {
            ESqlStatementType[] ses = {ESqlStatementType.sstcreateprocedure, ESqlStatementType.sstteradatacreatefunction, ESqlStatementType.sstcreatetrigger};
            if (this.includesqlstatementtype(this.gcurrentsqlstatement.sqlstatementtype, ses)) {
                gst = EFindSqlStateType.ststoredprocedure;
                this.gcurrentsqlstatement.sourcetokenlist.add(ast);
                if ((this.gcurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstcreateprocedure)
                        || (this.gcurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstteradatacreatefunction)
                        || (this.gcurrentsqlstatement.sqlstatementtype == ESqlStatementType.sstcreatetrigger)) {
                    this.curdelimiterchar = ';';
                }
            } else {
                gst = EFindSqlStateType.stsql;
                this.gcurrentsqlstatement.sourcetokenlist.add(ast);
            }
        }

        if ((!TBaseType.assigned(this.gcurrentsqlstatement)) && (ast.isFirstTokenOfLine())) {
            gst = this.flexer.cmdType(ast);
            if ((gst == EFindSqlStateType.stMultiLoadCmd) || (gst == EFindSqlStateType.stFastLoadCmd) || (gst == EFindSqlStateType.stFastExportCmd)) {
                this.gcurrentsqlstatement = new TTeradataBTEQCmd(this.vendor);
                ((TTeradataBTEQCmd)this.gcurrentsqlstatement).setFindSqlStateType(gst);
                this.gcurrentsqlstatement.sourcetokenlist.add(ast);
                return gst;
            }
            gst = EFindSqlStateType.stnormal;
        }

        if (!TBaseType.assigned(this.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;

            this.gcurrentsqlstatement = new TUnknownSqlStatement(this.vendor);
            this.gcurrentsqlstatement.sqlstatementtype = ESqlStatementType.sstinvalid;
            this.gcurrentsqlstatement.sourcetokenlist.add(ast);
        }
        return gst;
    }

    private EFindSqlStateType checkForBTEQOrUtilityCommand(TSourceToken ast, EFindSqlStateType gst) {
        // Check for .bteq commands: either "." at start of line, or "." after ";" at start of line
        boolean isDotAtStartOfLine = (ast.tokencode == '.') && (ast.isFirstTokenOfLine());
        boolean isDotAfterSemicolonAtStartOfLine = false;
        if ((ast.tokencode == '.') && !isDotAtStartOfLine) {
            TSourceToken prevToken = ast.prevSolidToken();
            if ((prevToken != null) && (prevToken.tokencode == ';') && (prevToken.isFirstTokenOfLine())) {
                isDotAfterSemicolonAtStartOfLine = true;
            }
        }

        if (isDotAtStartOfLine || isDotAfterSemicolonAtStartOfLine) {
            // .bteq commands
            TSourceToken nextst = ast.nextSolidToken();
            if (nextst != null) {
                gst = this.flexer.cmdType(nextst);
                boolean foundCmd = false;
                switch (gst) {
                    case stMultiLoadCmd:
                        this.gcurrentsqlstatement = new TTeradataMultiLoadCmd(this.vendor);
                        gst = EFindSqlStateType.stMultiLoadCmd;
                        ((TTeradataMultiLoadCmd)this.gcurrentsqlstatement).setCmdType(TTeradataHelper.searchMultiLoadTypeByName(nextst.getAstext()));
                        foundCmd = true;
                        break;
                    case stFastExportCmd:
                        this.gcurrentsqlstatement = new TTeradataFastExportCmd(this.vendor);
                        gst = EFindSqlStateType.stFastExportCmd;
                        foundCmd = true;
                        break;
                    case stFastLoadCmd:
                        this.gcurrentsqlstatement = new TTeradataFastLoadCmd(this.vendor);
                        gst = EFindSqlStateType.stFastLoadCmd;
                        foundCmd = true;
                        break;
                    case stBTEQCmd:
                        this.gcurrentsqlstatement = new TTeradataBTEQCmd(this.vendor);
                        ((TTeradataBTEQCmd)this.gcurrentsqlstatement).setBteqCmdType(BteqCmdType.searchBteqCmd(nextst));
                        gst = EFindSqlStateType.stBTEQCmd;
                        foundCmd = true;
                        break;
                    default:
                        break;
                }
                if (foundCmd) {
                    this.gcurrentsqlstatement.sourcetokenlist.add(ast);
                    return gst;
                }
            }
        } else if ((ast.tokencode == '*') && (ast.isFirstTokenOfLine())) {
            // BTEQ comment: * comment
            gst = EFindSqlStateType.stBTEQCmd;
            this.inBTEQComment = true;  // Mark that we're in a BTEQ comment
            this.gcurrentsqlstatement = new TTeradataBTEQCmd(this.vendor);
            ((TTeradataBTEQCmd)this.gcurrentsqlstatement).setBteqCmdType(BteqCmdType.COMMENT);
            this.gcurrentsqlstatement.sourcetokenlist.add(ast);
            return gst;
        } else if ((ast.tokencode == '=') && (ast.isFirstTokenOfLine())) {
            // BTEQ command starting with =
            TSourceToken st1 = ast.prevSolidToken();
            if ((st1 != null) && (st1.tokencode == ';')) {
                gst = EFindSqlStateType.stBTEQCmd;
                this.gcurrentsqlstatement = new TTeradataBTEQCmd(this.vendor);
                ((TTeradataBTEQCmd)this.gcurrentsqlstatement).setFindSqlStateType(gst);
                this.gcurrentsqlstatement.sourcetokenlist.add(ast);
                return gst;
            }
        } else if ((ast.isFirstTokenOfLine()) && (BteqCmdType.searchBteqCmd(ast) != null)) {
            TSourceToken st1 = ast.prevSolidToken();
            if ((st1 != null) && (st1.tokencode == ';')) {
                gst = EFindSqlStateType.stBTEQCmd;
                this.gcurrentsqlstatement = new TTeradataBTEQCmd(this.vendor);
                ((TTeradataBTEQCmd)this.gcurrentsqlstatement).setFindSqlStateType(gst);
                this.gcurrentsqlstatement.sourcetokenlist.add(ast);
                return gst;
            }
        } else if ((ast.tokencode == '&') && (ast.isFirstTokenOfLine())) {
            // Teradata macro/substitution variable: &VARIABLE_NAME at start of line
            // Treat it as a BTEQ-like command that ends at end of line
            TSourceToken nextst = ast.nextSolidToken();
            if (nextst != null && (nextst.tokencode == TBaseType.ident || nextst.tokentype == ETokenType.ttidentifier)) {
                gst = EFindSqlStateType.stBTEQCmd;
                this.gcurrentsqlstatement = new TTeradataBTEQCmd(this.vendor);
                ((TTeradataBTEQCmd)this.gcurrentsqlstatement).setFindSqlStateType(gst);
                this.gcurrentsqlstatement.sourcetokenlist.add(ast);
                return gst;
            }
        }
        return EFindSqlStateType.stnormal;
    }


    private boolean includesqlstatementtype(ESqlStatementType type, ESqlStatementType[] types) {
        for (ESqlStatementType t : types) {
            if (type != t) continue;
            return true;
        }
        return false;
    }

    @Override
    protected TStatementList performParsing(ParserContext context, TCustomParser parser, TCustomParser secondaryParser, TSourceTokenList tokens, TStatementList rawStatements) {
        this.fparser = (TParserTeradata)parser;
        this.sourcetokenlist = tokens;
        this.parserContext = context;
        this.sqlstatements = rawStatements;
        if (this.sqlstatements == null) {
            this.sqlstatements = new TStatementList();
            return this.sqlstatements;
        }
        if (this.sqlcmds == null) {
            this.sqlcmds = SqlCmdsFactory.get(this.vendor);
        }
        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) {
            gudusoft.gsqlparser.TGSqlParser gsqlparser = (gudusoft.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 gudusoft.gsqlparser.compiler.TContext();
            this.sqlEnv = new gudusoft.gsqlparser.sqlenv.TSQLEnv(this.vendor) {
                @Override
                public void initSQLEnv() {
                }
            };
            this.globalContext.setSqlEnv(this.sqlEnv, this.sqlstatements);
        } else {
            this.initializeGlobalContext();
        }

        for (int i = 0; i < this.sqlstatements.size(); ++i) {
            TCustomSqlStatement stmt = this.sqlstatements.getRawSql(i);
            try {
                stmt.setFrameStack(this.frameStack);
                int parseResult = stmt.parsestatement(null, false, context.isOnlyNeedRawParseTree());
                boolean doRecover = TBaseType.ENABLE_ERROR_RECOVER_IN_CREATE_TABLE;
                if (doRecover && (parseResult != 0 || stmt.getErrorCount() > 0)) {
                    this.handleCreateTableErrorRecovery(stmt);
                }
                if (parseResult == 0 && stmt.getErrorCount() <= 0) continue;
                this.copyErrorsFromStatement(stmt);
                continue;
            }
            catch (Exception ex) {
                ex.printStackTrace();
                this.handleStatementParsingException(stmt, i, ex);
            }
        }
        if (this.globalFrame != null) {
            this.globalFrame.popMeFromStack(this.frameStack);
        }
        return this.sqlstatements;
    }

    private void handleCreateTableErrorRecovery(TCustomSqlStatement stmt) {
        if (!(stmt.sqlstatementtype != ESqlStatementType.sstcreatetable && stmt.sqlstatementtype != ESqlStatementType.sstcreateindex || TBaseType.c_createTableStrictParsing)) {
            int nested = 0;
            boolean isIgnore = false;
            boolean 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 != 59) {
                        isFoundIgnoreToken = true;
                        if (firstIgnoreToken == null) {
                            firstIgnoreToken = st;
                        }
                    }
                    if (st.tokencode == 59) continue;
                    st.tokencode = 273;
                    continue;
                }
                if (st.tokencode == 41 && --nested == 0) {
                    isIgnore = true;
                }
                if (st.tokencode != 40) continue;
                ++nested;
            }
            if (isFoundIgnoreToken) {
                stmt.parsestatement(null, false, this.parserContext.isOnlyNeedRawParseTree());
            }
        }
    }

    @Override
    protected void performSemanticAnalysis(ParserContext context, TStatementList statements) {
        if (!TBaseType.isEnableResolver()) {
            return;
        }
        if (!this.getSyntaxErrors().isEmpty()) {
            return;
        }
        TSQLResolver resolver = new TSQLResolver(this.globalContext, statements);
        resolver.resolve();
    }

    @Override
    protected void performInterpreter(ParserContext context, TStatementList statements) {
    }

    @Override
    public String toString() {
        return "TeradataSqlParser{vendor=" + (Object)((Object)this.vendor) + "}";
    }
}