package gudusoft.gsqlparser.nodes;

import gudusoft.gsqlparser.*;
import gudusoft.gsqlparser.compiler.TVariable;
import gudusoft.gsqlparser.resolver.TColumnTableMatch;
import gudusoft.gsqlparser.sqlenv.*;
import gudusoft.gsqlparser.util.OraclePseudoColumnUtil;
import gudusoft.gsqlparser.util.SQLUtil;
import gudusoft.gsqlparser.util.keywordChecker;

import java.util.ArrayList;

/**
 * The qualified or unqualified name that identifies a database object.
 * The qualified name may includes those parts: server,database,schema,object,part and dblink.
 * This class represents database object in different database vendors such as Oracle, SQL Server in a uniform way.
 * <p>
 * The general syntax of database object in Oracle: [schema.]object[.part][@dblink]
 * <p>
 * The general syntax of database object in SQL Server: [server.][database.][schema.]object
 * <p>
 * The meaning of {@link #getObjectToken()} and {@link #getPartToken()} depends on the {@link #getDbObjectType()}.
 * If this database object is a schema object such as table, index, then the objectToken represents this
 * database object and partToken is null.
 * <p><p>
 * If this TObjectName represents a column, the partToken represents the column name, the objectToken is table/view
 * name of this column if this column is qualified like <code>table.column</code>, otherwise, the objectToken is
 * null.
 * <p>
 * schemaToken, databaseToken, serverToken is the qualified part of a database object name.
 * If this objectName represents a database name in the create database statement like this
 * <code>CREATE DATABASE menagerie</code>, then, the objectToken is menagerie and databaseToken is null.
 *
 * @see gudusoft.gsqlparser.EDbObjectType
 **/

public class TObjectName extends TParseTreeNode implements Cloneable{

    public void setOwnStmt(TCustomSqlStatement ownStmt) {
        this.ownStmt = ownStmt;
    }

    public TCustomSqlStatement getOwnStmt() {
        return ownStmt;
    }

    private TCustomSqlStatement ownStmt;


    private TExceptReplaceClause exceptReplaceClause;

    public TExceptReplaceClause getExceptReplaceClause() {
        return exceptReplaceClause;
    }

    public void setExceptReplaceClause(TExceptReplaceClause exceptReplaceClause) {
        this.exceptReplaceClause = exceptReplaceClause;
    }
        
    private ETableKind tableKind = ETableKind.etkBase;

    public void setTableKind(ETableKind tableKind) {
        this.tableKind = tableKind;
    }

    public ETableKind getTableKind() {
        return tableKind;
    }

    private EPseudoTableType pseudoTableType = EPseudoTableType.none;

    public EPseudoTableType getPseudoTableType() {
        return pseudoTableType;
    }

    public void setPseudoTableType(EPseudoTableType pseudoTableType) {
        this.pseudoTableType = pseudoTableType;
    }

    TVariable linkedVariable = null;

    public void setLinkedVariable(TVariable linkedVariable) {
        this.linkedVariable = linkedVariable;
        this.dbObjectType = EDbObjectType.variable;
    }

    public TVariable getLinkedVariable() {
        return linkedVariable;
    }

    // 如果该对象表示一个字段，那么本属性表示该字段的数据来自那个源字段
    private TAttributeNode sourceAttributeNode;

    /**
     * Sets the source attribute node for this object name.
     * <p>
     * This method is used only by the legacy TSQLResolver (RESOLVER).
     * It is not used when using TSQLResolver2 (RESOLVER2) for name resolution.
     * For RESOLVER2, use {@link #setResolution(gudusoft.gsqlparser.resolver2.model.ResolutionResult)} instead.
     *
     * @param sourceAttributeNode the attribute node representing the resolved source
     * @deprecated Since 3.4.0.5. Use TSQLResolver2 with {@link #setResolution} instead.
     */
    @Deprecated
    public void setSourceAttributeNode(TAttributeNode sourceAttributeNode) {
        this.sourceAttributeNode = sourceAttributeNode;
    }

    /**
     * Returns the source attribute node for this object name.
     * <p>
     * This method is used only by the legacy TSQLResolver (RESOLVER).
     * It is not used when using TSQLResolver2 (RESOLVER2) for name resolution.
     * For RESOLVER2, use {@link #getResolution()} instead.
     *
     * @return the attribute node representing the resolved source, or null if not resolved
     * @deprecated Since 3.4.0.5. Use TSQLResolver2 with {@link #getResolution()} instead.
     */
    @Deprecated
    public TAttributeNode getSourceAttributeNode() {
        return sourceAttributeNode;
    }

    // ===== New Resolver2 fields =====
    /**
     * Resolution result from the new resolver (resolver2).
     * Contains complete resolution status, column source, and candidate information.
     * This is set by gudusoft.gsqlparser.resolver2.NameResolver
     */
    private gudusoft.gsqlparser.resolver2.model.ResolutionResult resolution;

    /**
     * Side-channel hint for deep struct field access (3+ part names without alias).
     * Unlike resolution, this does NOT trigger sourceTable binding or affect lineage topology.
     * Set by NameResolver for BigQuery 3-part no-alias struct patterns.
     *
     * @see gudusoft.gsqlparser.resolver2.model.StructFieldHint
     */
    private gudusoft.gsqlparser.resolver2.model.StructFieldHint structFieldHint;

    /**
     * The syntax of this name for the nested-access normalizer: the identifier chain, the chain before a trailing
     * wildcard and the indirection, read from the name as it is now. Internal to the parser, resolver2 and lineage.
     * <p>
     * It is read afresh on every call, never cached: the name slots, tokens and indirection are public and mutable,
     * and the resolver's re-slotting ({@link #columnToFieldPath}, {@link #columnToProperty}) keeps the chain they read
     * (pinned by {@code TestNestedAccessNormalizer.aReResolvedNameKeepsItsPath}).
     */
    public gudusoft.gsqlparser.nodes.structured.NestedAccessSyntax getNestedAccessSyntax() {
        return gudusoft.gsqlparser.nodes.structured.NestedAccessSyntax.capture(this);
    }

    /** {@link gudusoft.gsqlparser.nodes.structured.NestedAccessNormalizer#normalize} of this name. */
    public gudusoft.gsqlparser.nodes.structured.NestedAccess getNestedAccess() {
        return gudusoft.gsqlparser.nodes.structured.NestedAccessNormalizer.normalize(this);
    }

    /** {@link gudusoft.gsqlparser.nodes.structured.NestedAccessNormalizer#normalizeStar} of this name. */
    public gudusoft.gsqlparser.nodes.structured.NestedAccess getNestedStarAccess() {
        return gudusoft.gsqlparser.nodes.structured.NestedAccessNormalizer.normalizeStar(this);
    }

    /**
     * Set resolution result (called by resolver2.NameResolver)
     */
    public void setResolution(gudusoft.gsqlparser.resolver2.model.ResolutionResult resolution) {
        this.resolution = resolution;

        // Synchronize sourceTable with resolution result
        // sourceTable represents the IMMEDIATE source table (subquery, CTE, or physical table)
        // NOT the final physical table after tracing through subqueries/CTEs
        if (resolution != null && resolution.getStatus() == gudusoft.gsqlparser.resolver2.ResolutionStatus.EXACT_MATCH) {
            gudusoft.gsqlparser.resolver2.model.ColumnSource source = resolution.getColumnSource();
            if (source != null) {
                // Get the immediate source table from the namespace that resolved this column
                gudusoft.gsqlparser.resolver2.namespace.INamespace sourceNs = source.getSourceNamespace();
                TTable immediateSource = (sourceNs != null) ? sourceNs.getSourceTable() : null;

                // For star columns, preserve the existing sourceTable set by linkColumnToTable
                // Star columns represent ALL columns from all tables in FROM clause
                String colName = this.getColumnNameOnly();
                if (colName != null && colName.equals("*")) {
                    // Don't update sourceTable for star columns
                } else if (immediateSource != null) {
                    // Special case: if Phase 1 (linkColumnToTable) already resolved to a physical table,
                    // and Phase 2 resolves to a CTE/subquery, check if they're referring to the same
                    // underlying table. If so, preserve Phase 1's physical table reference.
                    // This handles cases like non-recursive CTEs where a table reference inside the CTE
                    // definition should resolve to the physical table, not the CTE itself.
                    boolean preservePhase1 = false;
                    if (this.sourceTable != null && immediateSource != this.sourceTable) {
                        // Phase 1 already set sourceTable
                        ETableSource phase1Type = this.sourceTable.getTableType();
                        boolean phase1IsPhysical = (phase1Type == ETableSource.objectname);

                        // Check if Phase 2 resolved to CTE/subquery
                        boolean phase2IsCTEOrSubquery = immediateSource.isCTEName()
                            || immediateSource.getTableType() == ETableSource.subquery;

                        if (phase1IsPhysical && phase2IsCTEOrSubquery) {
                            // Get finalTable from Phase 2 resolution
                            TTable finalTable = source.getFinalTable();
                            // If finalTable matches Phase 1's sourceTable (same physical table),
                            // preserve Phase 1's result - BUT only for non-alias columns.
                            // For alias columns (e.g., SELECT t.id AS col1), the subquery layer
                            // must be preserved because the alias name doesn't exist in the physical table.
                            // We use getFinalColumnName() as a proxy: if it returns non-null, the column
                            // is an alias or passthrough-to-alias with a different name.
                            if (finalTable == this.sourceTable
                                    && !source.isColumnAlias()
                                    && source.getFinalColumnName() == null) {
                                preservePhase1 = true;
                            }
                        }
                    }

                    if (!preservePhase1) {
                        // Set sourceTable to the immediate source (subquery, CTE, or physical table)
                        this.sourceTable = immediateSource;
                    }
                }

                // Populate candidateTables from ColumnSource for UNION columns
                // When getFinalTable() is null but we have candidate tables (from UNION branches),
                // these should be tracked so the formatter can output all candidates
                java.util.List<TTable> sourceCandidates = source.getCandidateTables();
                if (sourceCandidates != null && !sourceCandidates.isEmpty()) {
                    if (candidateTables == null) {
                        candidateTables = new TTableList();
                    }
                    for (TTable candidate : sourceCandidates) {
                        if (candidate != null && !containsTable(candidateTables, candidate)) {
                            candidateTables.addTable(candidate);
                        }
                    }
                    // Check if candidates came from UNION/CTE propagation (not ambiguity)
                    // Evidence containing "union" or "propagate" indicates UNION branch tracing
                    String evidence = source.getEvidence();
                    if (evidence != null && (evidence.contains("union") || evidence.contains("propagate"))) {
                        candidatesFromUnion = true;
                    }
                }

                // Sync propertyToken for struct field access (backward compatibility)
                // When resolver2 detects struct field access (e.g., info.name where info is a RECORD column),
                // call columnToProperty() to shift tokens so propertyToken contains the field name.
                //
                // To avoid false positives (e.g., treating table.column as column.field when table not found),
                // we verify the base column is STRUCT type through:
                // 1. Semantic analysis: Check if ColumnSource's definition node has STRUCT datatype
                // 2. SQLEnv fallback: Check external metadata if semantic analysis inconclusive
                // 3. TableNamespace verification: If base column comes from a physical table, it's STRUCT
                //
                // Method 3 is key: if "info" resolves to a column in a real table (TableNamespace),
                // then "info.name" MUST be STRUCT field access (otherwise the SQL would be invalid).
                // This enables pure SQL-based STRUCT detection without DDL or metadata.
                if (source.isStructFieldAccess() && source.hasFieldPath()) {
                    String baseColumnName = source.getExposedName();
                    boolean isVerifiedStructColumn = false;

                    // Method 1: Semantic analysis - check ColumnSource's definition node for STRUCT type
                    // This works when DDL (CREATE TABLE with STRUCT columns) is parsed in the same batch
                    TParseTreeNode definitionNode = source.getDefinitionNode();
                    if (definitionNode instanceof TColumnDefinition) {
                        TColumnDefinition colDef = (TColumnDefinition) definitionNode;
                        TTypeName datatype = colDef.getDatatype();
                        if (datatype != null && datatype.getDataType() == EDataType.struct_t) {
                            isVerifiedStructColumn = true;
                        }
                    }

                    // Method 2: SQLEnv fallback - check external metadata if semantic analysis didn't verify
                    if (!isVerifiedStructColumn && this.sqlEnv != null && baseColumnName != null && immediateSource != null) {
                        String tableName = immediateSource.getFullName();
                        if (tableName != null) {
                            gudusoft.gsqlparser.sqlenv.TSQLTable sqlTable = this.sqlEnv.searchTable(tableName);
                            if (sqlTable != null) {
                                gudusoft.gsqlparser.sqlenv.TSQLColumn sqlColumn = sqlTable.getColumn(baseColumnName);
                                if (sqlColumn != null && sqlColumn.getColumnDataType() != null) {
                                    EDataType dataType = sqlColumn.getColumnDataType().getDataType();
                                    isVerifiedStructColumn = (dataType == EDataType.struct_t);
                                }
                            }
                        }
                    }

                    // Method 3: TableNamespace verification - if base column comes from a physical table
                    // When struct field fallback finds the base column (e.g., "info") in a TableNamespace,
                    // the SQL semantic guarantees it's a STRUCT column. If "info" is a regular column in
                    // table "student_records", then "info.name" can ONLY mean STRUCT field access.
                    // This enables STRUCT detection purely from SELECT statement semantics.
                    //
                    // DISABLED: This optimization causes regressions in complex queries where column names
                    // overlap with table aliases (e.g., UNION subqueries with NULL AS column_name).
                    // Users can access field names via source.getFieldPath().getFirst() instead.
                    // TODO: Implement smarter heuristic to detect truly "clear" semantics.
                    //
                    // if (!isVerifiedStructColumn && sourceNs instanceof gudusoft.gsqlparser.resolver2.namespace.TableNamespace) {
                    //     // Base column comes from a physical table - definitely STRUCT access
                    //     isVerifiedStructColumn = true;
                    // }

                    // Method 4 - Trino family (Athena, Presto, Trino): resolver2 reads a name as a field of a column
                    // only when its qualifier names no relation in scope, and Trino reads exactly such a
                    // qualifier as a column, so payload.items[1].name is the column payload with the field
                    // items even without DDL or metadata (Mantis 4811).
                    boolean trinoFamily = gudusoft.gsqlparser.nodes.structured.NestedAccessProfile.forVendor(this.dbvendor).readsFieldChains();
                    if (!isVerifiedStructColumn && trinoFamily) {
                        isVerifiedStructColumn = true;
                    }

                    // Method 5 - Redshift SUPER: resolver2 reads an attribute path of two or more parts only after a
                    // qualifier that names a relation in scope, o.customer.address.city, so the column customer is
                    // proven; the slots move as in the Trino family (Mantis 4839). Oracle keeps its slots: its
                    // grammar holds the parts after the column outside the identifier chain.
                    boolean attributePath = this.dbvendor == EDbVendor.dbvredshift && source.getFieldPath().size() >= 2;
                    if (!isVerifiedStructColumn && attributePath) {
                        isVerifiedStructColumn = true;
                    }

                    // Only call columnToProperty() for verified STRUCT columns and non-star columns
                    if (isVerifiedStructColumn) {
                        String currentColName = getColumnNameOnly();
                        if (currentColName == null || !currentColName.equals("*")) {
                            if (trinoFamily || attributePath) {
                                // the whole field path moves out of the name slots, not just one part:
                                // payload.address.city is the column payload (Mantis 4822)
                                columnToFieldPath(source.getFieldPath().size());
                            } else {
                                columnToProperty();
                            }
                        }
                    }
                }
            }
        }

        // Sync resolveStatus for backward compatibility with legacy code (e.g., TGetTableColumn)
        if (resolution != null) {
            switch (resolution.getStatus()) {
                case EXACT_MATCH:
                    this.resolveStatus = TBaseType.RESOLVED_AND_FOUND;
                    break;
                case AMBIGUOUS:
                    this.resolveStatus = TBaseType.RESOLVED_BUT_AMBIGUOUS;
                    break;
                case NOT_FOUND:
                    // Leave as NOT_RESOLVED_YET or whatever it was before
                    break;
            }
        }
    }

    /**
     * Helper to check if a table is already in the TTableList
     */
    private static boolean containsTable(TTableList list, TTable table) {
        if (list == null || table == null) return false;
        for (int i = 0; i < list.size(); i++) {
            TTable existing = list.getTable(i);
            if (existing == table) return true;
        }
        return false;
    }

    /**
     * Get resolution result from new resolver
     */
    public gudusoft.gsqlparser.resolver2.model.ResolutionResult getResolution() {
        return resolution;
    }

    /**
     * Convenience method: get column source (most common access pattern)
     */
    public gudusoft.gsqlparser.resolver2.model.ColumnSource getColumnSource() {
        if (resolution == null) return null;

        if (resolution.getStatus() == gudusoft.gsqlparser.resolver2.ResolutionStatus.EXACT_MATCH) {
            return resolution.getColumnSource();
        } else if (resolution.getStatus() == gudusoft.gsqlparser.resolver2.ResolutionStatus.AMBIGUOUS) {
            // For ambiguous: return first candidate (configurable behavior)
            gudusoft.gsqlparser.resolver2.model.AmbiguousColumnSource ambiguous = resolution.getAmbiguousSource();
            if (ambiguous != null && ambiguous.getCandidateCount() > 0) {
                return ambiguous.getCandidates().get(0);
            }
        }

        return null;
    }

    /**
     * Get the struct field hint for deep struct access (3+ part names without alias).
     * This is a side-channel annotation that does NOT affect resolution or sourceTable.
     *
     * @return The struct field hint, or null if not a deep struct access
     */
    public gudusoft.gsqlparser.resolver2.model.StructFieldHint getStructFieldHint() {
        return structFieldHint;
    }

    /**
     * Set the struct field hint (called by NameResolver for 3+ part no-alias struct patterns).
     */
    public void setStructFieldHint(gudusoft.gsqlparser.resolver2.model.StructFieldHint hint) {
        this.structFieldHint = hint;
    }

    /**
     * Check if this column reference is ambiguous
     */
    public boolean isAmbiguous() {
        return resolution != null &&
               resolution.getStatus() == gudusoft.gsqlparser.resolver2.ResolutionStatus.AMBIGUOUS;
    }

    /**
     * Check if this column reference has been resolved (by new resolver)
     */
    public boolean isResolved() {
        return resolution != null &&
               resolution.getStatus() != gudusoft.gsqlparser.resolver2.ResolutionStatus.NOT_FOUND;
    }

    /**
     * Get all candidate tables (for ambiguous columns)
     */
    public java.util.List<TTable> getCandidateTables2() {
        if (!isAmbiguous()) return java.util.Collections.emptyList();

        gudusoft.gsqlparser.resolver2.model.AmbiguousColumnSource ambiguous = resolution.getAmbiguousSource();
        return ambiguous.getCandidates().stream()
            .map(gudusoft.gsqlparser.resolver2.model.ColumnSource::getFinalTable)
            .filter(java.util.Objects::nonNull)
            .collect(java.util.stream.Collectors.toList());
    }
    // ===== End of New Resolver2 fields =====
//    private boolean isResolved = false;
//
//    public void setResolved(boolean resolved) {
//        isResolved = resolved;
//    }
//
//    public void setResolvedRelation(TTable resolvedRelation) {
//        this.resolvedRelation = resolvedRelation;
//        this.isResolved = true;
//    }
//
//    public boolean isResolved() {
//        return isResolved;
//    }
//
//    public TTable getResolvedRelation() {
//        return resolvedRelation;
//    }
//
//    private TTable resolvedRelation = null;

    public TObjectName clone(){
        TObjectName cloneObject = new TObjectName();
        cloneObject.dbObjectType = this.dbObjectType;
        cloneObject.dbvendor = this.dbvendor;

        if (this.partToken != null){
            cloneObject.partToken = this.partToken.clone();
        }
        if (this.objectToken != null){
            cloneObject.objectToken = this.objectToken.clone();
        }
        if (this.schemaToken != null){
        cloneObject.schemaToken = this.schemaToken.clone();
        }

        if (this.databaseToken != null){
            cloneObject.databaseToken = this.databaseToken.clone();
        }

        if (this.serverToken != null){
            cloneObject.serverToken = this.serverToken.clone();
        }

        if (this.propertyToken != null){
            cloneObject.propertyToken = this.propertyToken.clone();
        }

        if (this.methodToken != null){
            cloneObject.methodToken = this.methodToken.clone();
        }

        if (this.packageToken != null){
            cloneObject.packageToken = this.packageToken.clone();
        }

        cloneObject.numberOfPart = this.numberOfPart;

        // Clone additionalParts for deeply nested struct access
        if (this.additionalParts != null && !this.additionalParts.isEmpty()) {
            cloneObject.additionalParts = new java.util.ArrayList<>();
            for (TSourceToken token : this.additionalParts) {
                cloneObject.additionalParts.add(token.clone());
            }
        }

        // Copy startToken and endToken from parent TParseTreeNode
        if (this.getStartToken() != null) {
            cloneObject.setStartTokenDirectly(this.getStartToken());
        }
        if (this.getEndToken() != null) {
            cloneObject.setEndTokenDirectly(this.getEndToken());
        }

        return cloneObject;
    }

    private TObjectName parentObjectName;

    public void setParentObjectName(TObjectName parentObjectName) {
        this.parentObjectName = parentObjectName;
    }

    @Override
    public TObjectName getParentObjectName() {
        return parentObjectName;
    }

    public void setPath(TPathSqlNode path) {
        this.path = path;
        this.setEndToken(path.getEndToken());
    }

    /**
     *  stage path
     *
     * @return
     */
    public TPathSqlNode getPath() {
        return path;
    }

    private TPathSqlNode path;

//    private TObjectName cursorName;
//
//    public void setCursorName(TObjectName cursorName) {
//        this.cursorName = cursorName;
//    }
//
//    /**
//     * related cursor name if oracle for statement
//     * like: FOR emp_rec IN emp_cur
//     * @return
//     */
//    public TObjectName getCursorName() {
//        return cursorName;
//    }

    private ArrayList<TTable> sourceTableList;

    /**
     * source table list for star column,
     * <br>select * from emp,dept
     * <br> * column will be list to both emp and dept table.
     * <br>
     * @return
     */
    public ArrayList<TTable> getSourceTableList() {
        if (sourceTableList == null) {
            sourceTableList = new ArrayList<>();
        }
        return sourceTableList;
    }

    private boolean isImplicitSchema = false;
    private boolean isImplicitDatabase = false;

    public boolean isImplicitSchema() {
        return isImplicitSchema;
    }

    public boolean isImplicitDatabase() {
        return isImplicitDatabase;
    }

//    public void setOriginalQuery(TSelectSqlStatement originalQuery) {
//        this.originalQuery = originalQuery;
//    }
//
//    public TSelectSqlStatement getOriginalQuery() {
//        return originalQuery;
//    }
//
//    private TSelectSqlStatement originalQuery = null;

    private ArrayList<TAttributeNode> attributeNodesDerivedFromFromClause;

    /**
     * 这个属性只有当 column 为 * 时有效
     * 当 column 为 * 时， 本属性包含该 * 展开后对应的 attributeNode 列表，来源是 FROM CLAUSE中的 tables, 在 resolve star column
     * 时给本属性赋值， TStmtScope.resolve(TObjectName objectName)
     *
     * 当 table 有metadata或DDL给出了明确的字段时，每table个展开的 attributeNode 包含明确的字段名，such as t.c
     * 当 table 没有 metadata 和 DDL 时，每table个只展开的 一个 attributeNode，内容为 t.*
     *
     *
     * @return
     */
    public ArrayList<TAttributeNode> getAttributeNodesDerivedFromFromClause() {
        if (attributeNodesDerivedFromFromClause == null){
            attributeNodesDerivedFromFromClause = new ArrayList<TAttributeNode>();
        }
        return attributeNodesDerivedFromFromClause;
    }

    private ArrayList<TColumnTableMatch> candidateAttributeNodes;

    /**
     * 非 star column 使用该属性存放可能包含该 column 的 attributeNode
     * star column 使用 {@link #getAttributeNodesDerivedFromFromClause()}
     *
     * @return
     */
    public ArrayList<TColumnTableMatch> getCandidateAttributeNodes() {
        if (candidateAttributeNodes == null){
            candidateAttributeNodes = new ArrayList<TColumnTableMatch>();
        }
        return candidateAttributeNodes;
    }

    private TTableList candidateTables = null;

    public TTableList getCandidateTables() {
        if (candidateTables == null){
            candidateTables = new TTableList();
        }
        return candidateTables;
    }

    /** True if candidateTables came from UNION/CTE branch propagation, not from ambiguity */
    private boolean candidatesFromUnion = false;

    /**
     * Returns true if candidate tables came from UNION/CTE branch propagation,
     * false if they came from ambiguity (e.g., unqualified column in multi-table query).
     * When true, the formatter should output all candidates instead of marking as "missed".
     */
    public boolean isCandidatesFromUnion() {
        return candidatesFromUnion;
    }

    /**
     * Drop every candidate table recorded for this reference.
     *
     * <p>Needed when a reference is RE-BOUND away from the FROM-clause tables — a
     * WHERE reference corrected to a SELECT-list alias, for example. Clearing
     * {@code sourceTable} alone leaves the old candidates readable through
     * {@link #getCandidateTables()}, so a consumer reading candidates would still
     * publish tables the reference does not name (MantisBT 4659).</p>
     */
    public void clearCandidateTables() {
        if (candidateTables != null) {
            candidateTables.clear();
        }
        candidatesFromUnion = false;
    }

    /**
     * Check DDL verification status for a candidate table.
     *
     * <p>Returns a tri-state result:</p>
     * <ul>
     *   <li>1 = Column exists in table's DDL</li>
     *   <li>0 = Column NOT found in table's DDL (DDL available but column missing)</li>
     *   <li>-1 = Cannot verify (no DDL available for this table)</li>
     * </ul>
     *
     * @param table The candidate table to check
     * @return DDL verification status: 1 (exists), 0 (not found), -1 (no DDL)
     */
    public int getDdlVerificationStatus(TTable table) {
        String columnName = this.getColumnNameOnly();
        return gudusoft.gsqlparser.resolver2.model.ColumnSource.getDdlVerificationStatus(table, columnName);
    }

    /**
     * Get DDL verification status for all candidate tables.
     *
     * <p>Returns a map from each candidate table to its DDL verification status:</p>
     * <ul>
     *   <li>1 = Column exists in table's DDL</li>
     *   <li>0 = Column NOT found in table's DDL</li>
     *   <li>-1 = Cannot verify (no DDL available)</li>
     * </ul>
     *
     * @return Map of candidate tables to their DDL verification status, or empty map if no candidates
     */
    public java.util.Map<TTable, Integer> getCandidateTableDdlStatus() {
        java.util.Map<TTable, Integer> result = new java.util.LinkedHashMap<>();
        if (candidateTables == null || candidateTables.size() == 0) {
            return result;
        }

        String columnName = this.getColumnNameOnly();
        for (int i = 0; i < candidateTables.size(); i++) {
            TTable candidate = candidateTables.getTable(i);
            if (candidate != null) {
                int status = gudusoft.gsqlparser.resolver2.model.ColumnSource.getDdlVerificationStatus(candidate, columnName);
                result.put(candidate, status);
            }
        }
        return result;
    }

    private boolean isOrphanColumn = false;

    public void setOrphanColumn(boolean orphanColumn) {
        isOrphanColumn = orphanColumn;
    }

    public boolean isOrphanColumn() {
        return isOrphanColumn;
    }

    private boolean columnOnly = false;

    /**
     * Whether its position takes a column name only, so a variable or parameter of the same name is never read there:
     * the argument of MySQL {@code VALUES(col)} and {@code DEFAULT(col)}.
     *
     * @return true for a name that can only be a column
     */
    public boolean isColumnOnly() {
        return columnOnly;
    }

    public void setColumnOnly(boolean columnOnly) {
        this.columnOnly = columnOnly;
    }

    private boolean isReservedKeyword = false;

    public boolean isReservedKeyword() {
        return isReservedKeyword;
    }

    private TColumnDefinition linkedColumnDef = null;

    public void setLinkedColumnDef(TColumnDefinition linkedColumnDef) {
        this.linkedColumnDef = linkedColumnDef;
    }

    /**
     * The column definition in create/alter table statement that include this column name object.
     * <pre>
     *     CREATE TABLE table_name (
     *       column1 datatype,
     *       column2 datatype
     *    );
     * </pre>
     * In above SQL, <code>column1 datatype</code> is the column definition while <code>column1</code> is this
     * object name.
     * @return column definition in create/alter table statement
     */
    public TColumnDefinition getLinkedColumnDef() {

        return linkedColumnDef;
    }

    private TObjectName namespace;

    public void setNamespace(TObjectName namespace) {
        this.namespace = namespace;
    }

    /**
     * The Couchbase namespace before keyspace
     * @return the namespace
     */
    public TObjectName getNamespace() {

        return namespace;
    }

    /**
     * 返回该对象名的字符串表示（中文说明）：
     * <p>
     * 1) 优先调用父类 {@link TBaseType#toString()} 获取已构造好的整体标识文本；
     * 若父类返回非空，则：
     *   - 对于 Snowflake，当 token 构成 <code>IDENTIFIER(...)</code> 形式时，仅提取并返回其中的
     *     字面量部分（去除引号），以符合 Snowflake 标识符解析规则；
     *   - 其他情况直接返回父类结果。
     * <p>
     * 2) 若父类返回为空（尚未生成整体文本），则回退到更细粒度的 token：
     *   - 若存在 <code>part</code> 级 token，返回其字符串；
     *   - 否则若存在 <code>object</code> 级 token，返回其字符串；
     *   - 若仍不存在，返回 null。
     * <p>
     * 目的：统一并优先复用已构造的字符串表示，同时兼容特定数据库（如 Snowflake）的
     * 标识符语义，从而在不同厂商 SQL 中提供稳定、符合预期的对象名输出。
     */
    public String toString() {
        String ret = super.toString();

        if (ret != null) {
            if (isSnowflakeIdentifierName()) {
                // snowflake identifier name: IDENTIFIER( { string_literal | session_variable | bind_variable | snowflake_scripting_variable } )
                // only return the string_literal part
                // https://www.sqlparser.com/bugs/mantisbt/view.php?id=3566
                // When parts have been split (mantis #4237), reconstruct the full qualified name
                StringBuilder sb = new StringBuilder();
                if (getDatabaseString() != null && !getDatabaseString().isEmpty()) {
                    sb.append(getDatabaseString()).append(".");
                }
                if (getSchemaString() != null && !getSchemaString().isEmpty()) {
                    sb.append(getSchemaString()).append(".");
                }
                sb.append(getObjectString());
                return sb.toString();
            }
            return ret;
        }

        if (getPartToken() != null) return getPartString();
        if (getObjectToken() != null ) return getObjectString();

        return  null;
    }

    /**
     * Recognize the IDENTIFIER wrapper by tokens so intervening whitespace and
     * comments do not leak into the published object name (Mantis #4714).
     * Ordinary names such as IDENTIFIER or IDENTIFIER.col are not wrappers.
     */
    private boolean isSnowflakeIdentifierName() {
        if (dbvendor != EDbVendor.dbvsnowflake) return false;
        TSourceToken first = getStartToken();
        TSourceToken last = getEndToken();
        if (first == null || last == null || first == last) return false;
        if (!"IDENTIFIER".equalsIgnoreCase(first.toString())) return false; // non-identifier-compare: SQL wrapper keyword
        TSourceToken opening = first.nextSolidToken();
        return opening != null && "(".equals(opening.toString())
                && ")".equals(last.toString());
    }

    public void setQuoteType(EQuoteType quoteType) {
        this.quoteType = quoteType;
    }

    /**
     * Tell whether this is a quoted objectName.
     * @return EQuoteType.squareBracket or EQuoteType.doubleQuote if this objectName is quoted.
     */
    public EQuoteType getQuoteType() {
        if (toString().startsWith("[")){
            return EQuoteType.squareBracket;
        }else if (toString().startsWith("\"")){
            return EQuoteType.doubleQuote;
        }else if (toString().startsWith("`")){
            return EQuoteType.backtick;
        }else
            return quoteType;
    }

    private EQuoteType quoteType = EQuoteType.notQuoted;
//    private String stringValue;



    /**
     * Internal use only
     */
    public int searchLevel = 0;

    public boolean isContinueToSearch(){
        // if column is in where clause, we can search 10 levels up

        // if column is in select list, only select one level up.
        // only search one level up, c:\prg\gsp_sqlfiles\TestCases\java\oracle\dbobject\berger_sqltest_04.sql

        if (this.getLocation() == ESqlClause.where) return (searchLevel < 10);
        else return (searchLevel < 1);
    }
    private TResultColumn sourceColumn;

    /**
     * Set the result column which include this column name. Used by parser internally.
     *
     * @param sourceColumn the result column includes this column name
     */
    public void setSourceColumn(TResultColumn sourceColumn) {
        this.sourceColumn = sourceColumn;
        this.setDbObjectTypeDirectly(EDbObjectType.column);
    }

    /**
     * Set the source column without changing dbObjectType.
     * Used by resolver2 for legacy API compatibility when the column
     * is already properly typed (e.g., star-inferred columns).
     *
     * @param sourceColumn the result column includes this column name
     */
    public void setSourceColumnOnly(TResultColumn sourceColumn) {
        this.sourceColumn = sourceColumn;
    }

    /**
     * The result column which include this column
     * <pre>
     *     select salary + 1000 from emp
     * </pre>
     * In the above SQL, <code>salary + 1000</code> is the result column while <code>salary</code> is this column name.
     *
     * @return the result column includes this column name
     */
    private TCTE expressionCteRef = null;

    /**
     * ClickHouse: when this unqualified column reference is actually the alias
     * of an expression-CTE ({@code WITH <expr> AS ident}), the CTE it refers
     * to; null otherwise. Such a reference names a scalar expression, not a
     * column of any table — {@link #getSourceTable()} is intentionally null.
     */
    public TCTE getExpressionCteRef() {
        return expressionCteRef;
    }

    public void setExpressionCteRef(TCTE expressionCteRef) {
        this.expressionCteRef = expressionCteRef;
    }

    public TResultColumn getSourceColumn() {

        return sourceColumn;
    }

    /**
     * The <b>immediate</b> source table where this column is visible in the current scope.
     *
     * <p>This represents the table/subquery/CTE that directly exposes this column in the FROM clause,
     * NOT the final physical table after tracing through subqueries or CTEs.</p>
     *
     * <h3>Semantic Difference: sourceTable vs finalTable</h3>
     * <ul>
     *   <li><b>sourceTable</b> (this field): The immediate/direct source in the current scope.
     *       For a column from a subquery, this points to the subquery's TTable.</li>
     *   <li><b>finalTable</b> (via {@code getResolution().getColumnSource().getFinalTable()}):
     *       The final physical table after tracing through all subqueries and CTEs.</li>
     * </ul>
     *
     * <h3>Example</h3>
     * <pre>{@code
     * SELECT title FROM (SELECT * FROM books) sub
     *
     * For the 'title' column in outer SELECT:
     * - sourceTable = TTable for subquery 'sub' (tableType=subquery)
     * - finalTable  = TTable for 'books' (the physical table)
     * }</pre>
     *
     * @see #getSourceTable()
     * @see gudusoft.gsqlparser.resolver2.model.ColumnSource#getFinalTable()
     */
    private TTable sourceTable;

    /**
     * This column must be in this syntax: table.column, otherwise, this method always return false.
     * Match tableToken with the input pTable, compare the alias of pTable to tableToken at first,
     * If not the same, then compare the table name directly. This method can handle quoted name correctly.
     *
     * This method is used by parser internally.
     *
     * @param pTable table used to match {@link #getTableToken()} of this column object
     * @return true if input table is matched with tableToken of this column object
     */
    public boolean resolveWithThisTable(TTable pTable){
        boolean lcResult = false;
        if (getTableString().length() == 0) return false;
        if (pTable.getAliasName().length() > 0) {
            lcResult = pTable.checkTableByName(getTableString().toString()); //pTable.getAliasName().toString().equalsIgnoreCase(getTableString().toString());
            if ((!lcResult)&&(getSchemaString().length()>0)&&(this.databaseToken == null)){
                // Only apply alias-to-schema matching for 3-part names (alias.column.field).
                // For 4-part names (db.schema.table.column), databaseToken is set and the
                // schema position IS the schema, not an alias. (Mantis #4268)
                lcResult = SQLUtil.sameName(this.dbvendor, ESQLDataObjectType.dotTable, pTable.getAliasName().toString(), getSchemaString().toString());
                if (lcResult){
                    // table.column.field, table was recognized as schema in the parser, change the part token to property token
                    this.columnToProperty();
                }
            }
        }
        if (lcResult) return true;

        if (((pTable.isBaseTable()||(pTable.isCTEName()))&&(getTableToken() != null)&&(pTable.getTableName().getTableToken() != null))) {
            // P0d.3b: canonical equality on the raw token texts replaces the
            // strip-quotes-then-equalsIgnoreCase collapse (quoted-case distinctions
            // survive where the vendor preserves them).
            lcResult = SQLUtil.sameName(this.dbvendor, ESQLDataObjectType.dotTable,
                    getTableToken().toString(), pTable.getTableName().getTableToken().toString());

            if (lcResult && (!pTable.getPrefixDatabase().isEmpty()) && (!this.getDatabaseString().isEmpty()) && (!SQLUtil.sameName(this.dbvendor, ESQLDataObjectType.dotCatalog, pTable.getPrefixDatabase(), this.getDatabaseString().toString()))) {
                // teradata: UPDATE foodmart.STRTOK_TIME A SET SYSTEM_DESK = testdatabase.STRTOK_TIME.SYSTEM_DESK
                // table STRTOK_TIME in testdatabase should be treat as the same one in foodmart
                lcResult = false;
            }


            if ((!lcResult)&&(getSchemaString().length()>0)&&(this.databaseToken == null)){
                // Only apply table-name-to-schema matching for 3-part names (table.column.field).
                // For 4-part names (db.schema.table.column), databaseToken is set and the
                // schema position IS the schema, not a table name. (Mantis #4268)
                lcResult = SQLUtil.sameName(this.dbvendor, ESQLDataObjectType.dotTable,
                        pTable.getTableName().getTableToken().toString(), getSchemaString().toString());
                if (lcResult){
                    // table.column.field, table was recognized as schema in the parser, change the part token to property token
                    this.columnToProperty();
                }
            }
        }
        return lcResult;
    }

    /**
     * Apply the qualifier rule of {@link #resolveWithThisTable(TTable)} to a column that is
     * bound to {@code pBoundTable} by its position rather than found by a name lookup.
     * <p>
     * The grammar splits every three-part name as {@code schema.table.column}. A column found
     * by name lookup passes through {@link #resolveWithThisTable(TTable)}, which re-reads
     * {@code alias.column.attribute} as column plus {@link #getPropertyToken()} once the head
     * turns out to name the table. A DML target column, such as the left-hand side of an
     * UPDATE or MERGE {@code SET} or an INSERT or MERGE INSERT column list, belongs to the
     * target table because of where it stands, so it never reached that lookup. It kept the
     * target's alias as its schema and the object column as its table: Oracle
     * {@code UPDATE SET tgt.objcol.attr = v} was reported as column {@code attr} of a table
     * {@code objcol} in a schema {@code tgt} (Mantis #4747).
     * <p>
     * This method delegates to {@link #resolveWithThisTable(TTable)} so that both kinds of
     * binding split a name by the same rule. The match result is not needed: the caller has
     * already bound the column to {@code pBoundTable}.
     *
     * @param pBoundTable the table this column is bound to by its position, may be null
     */
    public void columnToPropertyIfQualifiedByTable(TTable pBoundTable){
        if (pBoundTable == null) return;
        resolveWithThisTable(pBoundTable);
    }

    /**
     * Check whether a column is prefixed by a table like this: <code>table.column</code>
     *
     * @return true if this column is in syntax like this: <code>table.column</code>
     */
    public boolean isQualified(){
        return (getTableString().length() > 0);
    }

    public int getValidate_column_status() {
        return validate_column_status;
    }

    public void setValidate_column_status(int validate_column_status) {
        this.validate_column_status = validate_column_status;
    }

    private int validate_column_status = TBaseType.CAN_BE_COLUMN_NOT_VALIDATE_YET;
    /**
     * Check whether a column name is syntax valid in a specific database vendor.
     * For example, in Oracle, <code>rowid</code> is not a valid column name.
     *
     * @param pDBVendor in which the database vendor the syntax of this column is checked
     * @return true if this objectName can be used as a column name in the specified database
     */
    public boolean isValidColumnName(EDbVendor pDBVendor){
       boolean lcResult = true;
       if (validate_column_status == TBaseType.VALIDATED_CAN_BE_A_COLUMN_NAME) return true;
       if (validate_column_status == TBaseType.VALIDATED_CAN_NOT_BE_A_COLUMN_NAME) return false;
       if (validate_column_status == TBaseType.MARKED_NOT_A_COLUMN_IN_COLUMN_RESOLVER) return false;
       if (validate_column_status == TBaseType.COLUMN_LINKED_TO_COLUMN_ALIAS_IN_OLD_ALGORITHM) return false;



       if ((getObjectType() == TObjectName.ttobjVariable)
               ||(getDbObjectType() == EDbObjectType.variable)
               ||(getObjectType() == TObjectName.ttobjColumnAlias)
               || (getDbObjectType() == EDbObjectType.xmlElement)
               || (getDbObjectType() == EDbObjectType.date_time_part)
               || (getDbObjectType() == EDbObjectType.constant)
               || (getDbObjectType() == EDbObjectType.function)
       ) {
            validate_column_status = TBaseType.VALIDATED_CAN_NOT_BE_A_COLUMN_NAME;
            return false;
        }

        // Numeric literals (e.g., "5" in LIMIT 5, "10" in TOP 10) are never valid column names.
        // Some grammars wrap Number tokens in createObjectName() which causes them to flow through
        // column linking. The lexer may assign ttkeyword or ttnumber as the token type depending
        // on the vendor, so we check both the token type and the actual text content.
        // This check is vendor-agnostic since no SQL dialect allows unquoted numeric literals
        // as column names.
        if (getPartToken() != null) {
            TSourceToken pt = getPartToken();
            if (pt.tokentype == ETokenType.ttnumber) {
                validate_column_status = TBaseType.VALIDATED_CAN_NOT_BE_A_COLUMN_NAME;
                return false;
            }
            // Some lexers (e.g., Hive) assign ttkeyword to Number tokens.
            // Check if the text is a numeric literal (integer or decimal).
            String tokenText = pt.toString();
            if (tokenText.length() > 0 && isNumericLiteral(tokenText)) {
                validate_column_status = TBaseType.VALIDATED_CAN_NOT_BE_A_COLUMN_NAME;
                return false;
            }
        }

        if (pDBVendor == EDbVendor.dbvsybase || pDBVendor == EDbVendor.dbvsybasease || pDBVendor == EDbVendor.dbvsqlanywhere || pDBVendor == EDbVendor.dbvsybaseiq){
            TSourceToken pt = getPartToken();
            if ( pt != null){
                if (pt.tokentype == ETokenType.ttdqstring){
                    //"0123", quoted string start with a number can't a column
                    if ((pt.toString().charAt(1) >= '0')
                            &&(pt.toString().charAt(1) <= '9')){
                        lcResult = false;
                    }else if (pt.toString().length() == 2){
                        //"", empty
                        lcResult = false;
                    }else if (pt.toString().substring(1,pt.toString().length()-1).trim().length() == 0){
                        //"  "
                        lcResult = false;
                    }
                }
            }
        }

        if (getPartToken() != null){
            if (getPartToken().tokentype == ETokenType.ttkeyword){

                switch (pDBVendor){
                    case dbvmssql:
                        //lcResult = this.getGsqlparser().getFlexer().canBeColumnName(getPartToken().tokencode);
                        lcResult = TLexerMssql.canBeColumnName(getPartToken().tokencode);
                        break;
                    case dbvsybase:
                        lcResult = !keywordChecker.isKeyword(getPartToken().toString(), EDbVendor.dbvsybase, "15.7", true);
                        break;
                    case dbvsybasease:
                        // Shares dbvsybase's keyword DATA file (it is the ASE
                        // reserved-word list); independent case per HC-5.
                        lcResult = !keywordChecker.isKeyword(getPartToken().toString(), EDbVendor.dbvsybase, "15.7", true);
                        break;
                    case dbvsqlanywhere:
                        // Same shared keyword DATA file; independent case per HC-5.
                        lcResult = !keywordChecker.isKeyword(getPartToken().toString(), EDbVendor.dbvsybase, "15.7", true);
                        break;
                    case dbvsybaseiq:
                        // Same again; independent case per HC-5.
                        lcResult = !keywordChecker.isKeyword(getPartToken().toString(), EDbVendor.dbvsybase, "15.7", true);
                        break;
                    default:
                        break;
                }
            }
        }

        if ((toString().startsWith("@"))||((toString().startsWith(":"))&&(toString().indexOf(".")==-1)))
        {
            setObjectType(TObjectName.ttobjNotAObject);
            lcResult = false;
        }

        switch (pDBVendor){
            case dbvoracle:
                // Only names that need no statement context belong here. This
                // used to name "nextval" but not "currval", so the two sequence
                // pseudocolumns got opposite answers for the same expression
                // shape (Mantis #4675). Deciding them here is not possible
                // either way: telling seq.CURRVAL from tablealias.CURRVAL needs
                // to know what is in the FROM clause, which this method cannot
                // see. Both are now decided once, with that context, by
                // TCustomSqlStatement.isOraclePseudoColumnReference(), whose
                // mark this method already honours through the
                // MARKED_NOT_A_COLUMN_IN_COLUMN_RESOLVER short-circuit above.
                if ( (getColumnNameOnly().compareToIgnoreCase ("sysdate") == 0)
                        || (getColumnNameOnly().compareToIgnoreCase ("user") == 0)
                        || OraclePseudoColumnUtil.isDetachedReservedPseudoColumn(getColumnNameOnly())
                ){
                    setObjectType(TObjectName.ttobjNotAObject);
                    lcResult = false;
                }
                if ((toString().startsWith(":"))&&(toString().indexOf(".") == -1))
                { // :bindv, but :new.column should not be enter here
                    setObjectType(TObjectName.ttobjNotAObject);
                    lcResult = false;
                }
                break;
            case dbvdameng:
                if ( (getColumnNameOnly().compareToIgnoreCase ("sysdate") == 0)
                        || (getColumnNameOnly().compareToIgnoreCase ("nextval") == 0)
                        || (getColumnNameOnly().compareToIgnoreCase ("rownum") == 0)
                        || (getColumnNameOnly().compareToIgnoreCase ("level") == 0)
                        || (getColumnNameOnly().compareToIgnoreCase ("user") == 0)
                ){
                    setObjectType(TObjectName.ttobjNotAObject);
                    lcResult = false;
                }
                if ((toString().startsWith(":"))&&(toString().indexOf(".") == -1))
                {
                    setObjectType(TObjectName.ttobjNotAObject);
                    lcResult = false;
                }
                break;
            case dbvmssql:
                if ((getColumnNameOnly().compareToIgnoreCase ("system_user") == 0)
                ){
                    //setObjectType(TObjectName.ttobjNotAObject);
                    lcResult = false;
                }
                break;
            case dbvmysql:
                if (toString().startsWith("\"")){
                    // "X" is a string literal
                    lcResult = false;
                }
                // Skip reserved keyword check if the token was converted to IDENT (264)
                // by the yyparse() keyword-as-column-name lookahead
                if (getPartToken() != null && getPartToken().tokencode == 264) {
                    break;
                }
                if (keywordChecker.isKeyword(toString(),EDbVendor.dbvmysql,"6.0",true)){
                    isReservedKeyword = true;
                    lcResult = false;
                }
                break;
            case dbvoceanbase:
                // MySQL/system tenant: MySQL's rules, a "string" is not a column and a reserved word is not a column
                // (Mantis 4813, Codex review); Oracle tenant: no rule here, as before
                if (gudusoft.gsqlparser.TCustomSqlStatement.isMySQLDialect(pDBVendor, getGsqlparser())){
                    if (toString().startsWith("\"")){
                        lcResult = false;
                    }
                    if (getPartToken() != null && getPartToken().tokencode == 264) {
                        break;
                    }
                    if (keywordChecker.isKeyword(toString(),EDbVendor.dbvmysql,"6.0",true)){
                        isReservedKeyword = true;
                        lcResult = false;
                    }
                }
                break;
            case dbvteradata:
                if ((getObjectString().length() == 0)&&((getColumnNameOnly().compareToIgnoreCase ("account") == 0)
                        ||(getColumnNameOnly().compareToIgnoreCase ("current_date") == 0)
                        ||(getColumnNameOnly().compareToIgnoreCase ("current_role") == 0)
                        ||(getColumnNameOnly().compareToIgnoreCase ("current_time") == 0)
                        ||(getColumnNameOnly().compareToIgnoreCase ("current_timestamp") == 0)
                        ||(getColumnNameOnly().compareToIgnoreCase ("current_user") == 0)
                        ||(getColumnNameOnly().compareToIgnoreCase ("database") == 0)
                        ||((getColumnNameOnly().compareToIgnoreCase ("date") == 0)&&( this.getDbObjectType() != EDbObjectType.column ))
                        ||(getColumnNameOnly().compareToIgnoreCase ("profile") == 0)
                        ||(getColumnNameOnly().compareToIgnoreCase ("role") == 0)
                        ||(getColumnNameOnly().compareToIgnoreCase ("session") == 0)
                        ||(getColumnNameOnly().compareToIgnoreCase ("time") == 0)
                        ||(getColumnNameOnly().compareToIgnoreCase ("user") == 0)
                        ||(getColumnNameOnly().compareToIgnoreCase ("sysdate") == 0)
                )){
                    lcResult = false;
                }
                break;
            case dbvpostgresql:
                if (toString().startsWith("$")){
                    if ((toString().charAt(1) >= '0')
                            &&(toString().charAt(1) <= '9')){
                        this.setDbObjectType(EDbObjectType.variable);
                        lcResult = false;
                    }
                }
                break;
            case dbvbigquery:
                if ((getColumnNameOnly().compareToIgnoreCase ("CURRENT_DATE") == 0)
                         ||(getColumnNameOnly().compareToIgnoreCase ("CURRENT_TIME") == 0)
                        ||(getColumnNameOnly().compareToIgnoreCase ("CURRENT_TIMESTAMP") == 0)
                ){
                    //setObjectType(TObjectName.ttobjNotAObject);
                    lcResult = false;
                }
                break;
        }

       if(lcResult){
           validate_column_status = TBaseType.VALIDATED_CAN_BE_A_COLUMN_NAME;
       }else{
           validate_column_status = TBaseType.VALIDATED_CAN_NOT_BE_A_COLUMN_NAME;
       }

       return lcResult;

    }

    /**
     * Check if a string represents a numeric literal (integer or decimal).
     * Examples: "5", "10", "3.14", ".5"
     */
    private static boolean isNumericLiteral(String text) {
        if (text == null || text.isEmpty()) return false;
        boolean hasDigit = false;
        boolean hasDot = false;
        for (int i = 0; i < text.length(); i++) {
            char c = text.charAt(i);
            if (c >= '0' && c <= '9') {
                hasDigit = true;
            } else if (c == '.' && !hasDot) {
                hasDot = true;
            } else {
                return false;
            }
        }
        return hasDigit;
    }

    private boolean expandStarColumns = false;
    ArrayList<String> expandedStarColumns = new ArrayList<>();

    public ArrayList<String> getColumnsLinkedToStarColumn() {
        if (expandStarColumns) return expandedStarColumns;

        //TTable sourceTable = this.getSourceTable();
        if (getSourceTableList().size() > 0){
            for( int i = 0;i < getSourceTableList().size();i++){
                for(String c:getSourceTableList().get(i).getExpandedStarColumns()){
                    expandedStarColumns.add(c);
                }
            }
        }

        expandStarColumns = true;
        return expandedStarColumns;

    }

    private ArrayList<String> columnsLinkedToStarColumn = new ArrayList<String>();

    private TResultColumnList columnsLinkedToStar;

    public void setColumnsLinkedToStar(TResultColumnList columnsLinkedToStar) {
        this.columnsLinkedToStar = columnsLinkedToStar;
        for(TResultColumn rc:columnsLinkedToStar){
            if (rc.getColumnAlias()!= ""){
                columnsLinkedToStarColumn.add(rc.getColumnAlias());
            }else{
                columnsLinkedToStarColumn.add(rc.getColumnNameOnly());
            }
        }

        this.setDbObjectTypeDirectly(EDbObjectType.column);
    }

    /**
     * if this is a star column(column name is *), and the value of this star column
     * is derived from a subquery, then, this field points to the select list in the subquery
     *
     * @return the select list in the subquery
     */
    public TResultColumnList getColumnsLinkedToStar() {
        return columnsLinkedToStar;
    }

    /**
     * Set the table this column belongs to. Used by parser internally.
     *
     * @param sourceTable table contains this column
     */
    public void setSourceTable(TTable sourceTable) {

        // INSERT INTO "omni"."omni_upload_t1a8067802b804755b1d29ee935b3b0bc" VALUES ($1, $2, $3, $4, $5)
        // if this objectname is $1, then just return
        if (this.getDbObjectType() == EDbObjectType.parameter) {
            // to avoid this parameter been checked in TAttributeResolver preVisit(TObjectName attribute)
            this.setValidate_column_status(TBaseType.COLUMN_LINKED_TO_TABLE_IN_OLD_ALGORITHM);
            return;
        }

        this.sourceTable = sourceTable;
        // 如果 column token 的 tokentype 为 ETokenType.ttkeyword， 那么调整为 ETokenType.ttidentifier
        if ((this.getPartToken() != null)&&(this.getPartToken().tokentype == ETokenType.ttkeyword)){
            if ((this.getPartToken().getDbObjectType() == EDbObjectType.column)||(this.getPartToken().getDbObjectType() == EDbObjectType.unknown)){
                this.getPartToken().tokentype = ETokenType.ttidentifier;
            }
        }
        // setDbObjectTypeDirectly() downgrades this to notAColumn for a
        // table-scoped Oracle pseudocolumn (ROWID), which keeps the table it
        // came from but must not be reported as a column of it.
        this.setDbObjectTypeDirectly(EDbObjectType.column);

        // If this column was previously an orphan and is now linked to a table,
        // remove it from the orphanColumns list of its owning statement
        if (sourceTable != null && this.isOrphanColumn() && this.getOwnStmt() != null) {
            TObjectNameList orphanColumns = this.getOwnStmt().getOrphanColumns();
            if (orphanColumns != null) {
                orphanColumns.removeElement(this);
            }
            this.setOrphanColumn(false);
        }
    }

    public void setSourceTableBySQLResolver(TCustomSqlStatement sqlStatement, TAttributeNode attributeNode, TTable newSourceTable) {
        // 如果 column token 的 tokentype 为 ETokenType.ttkeyword， 那么调整为 ETokenType.ttidentifier
        if ((this.getPartToken() != null)&&(this.getPartToken().tokentype == ETokenType.ttkeyword)){
            if ((this.getPartToken().getDbObjectType() == EDbObjectType.column)||(this.getPartToken().getDbObjectType() == EDbObjectType.unknown)){
                this.getPartToken().tokentype = ETokenType.ttidentifier;
            }
        }

        if ((this.sourceTable != null) && (this.sourceTable.equals(newSourceTable))) return;

        if ((this.getResolveStatus() == TBaseType.RESOLVED_AND_FOUND ) 
                || (newSourceTable.getTableType() != ETableSource.subquery)){// 关联到 subquery 的 column 本能算真正找到 table，因此还不能去掉 orphan column
            if (sqlStatement.getOrphanColumns().removeElement(this)){
                if (TBaseType.DUMP_RESOLVER_LOG_TO_CONSOLE){
                    TBaseType.log(String.format("Remove orphan column <%s> find in old algorithm",this.toString()),TLog.WARNING,this);
                }
                // remove the waring in sql statement's error syntax list
                TCustomSqlStatement currentStatement = sqlStatement;
                while (currentStatement != null) {
                    if (currentStatement.getSyntaxHints() != null) {
                        for(int i=0; i<currentStatement.getSyntaxHints().size(); i++) {
                            TSyntaxError syntaxError = currentStatement.getSyntaxHints().get(i);
                            if (syntaxError.errortype == EErrorType.sphint) {
                                if ((syntaxError.lineNo == this.getStartToken().lineNo)||(syntaxError.columnNo == this.getStartToken().columnNo)) {
                                    currentStatement.getSyntaxHints().remove(i);
                                    if (TBaseType.DUMP_RESOLVER_LOG_TO_CONSOLE){
                                        TBaseType.log(String.format("Remove orphan column <%s> warning message in old algorithm", this.toString()), TLog.WARNING, this);
                                    }
                                    break;
                                }
                            }
                        }
                    }
                    currentStatement = currentStatement.getParentStmt();
                }
            }
        }else{
            TBaseType.log(String.format("Found orphan column <%s> find in old algorithm in subquery %s, but NOT remove it from orphan list",this.toString(),newSourceTable.getAliasName()),TLog.WARNING,this);
        }

        if (this.sourceTable != null){
            if (this.sourceTable.getLinkedColumns().removeElement(this)){
                if (TBaseType.DUMP_RESOLVER_LOG_TO_CONSOLE){
                    TBaseType.log(String.format("Remove <%s> at addr: %s from table <%s> that found in old algorithm, new linked table is: %s"
                            ,this.toString(),Integer.toHexString(this.hashCode()),this.sourceTable.toString(),newSourceTable.toString())
                            ,TLog.WARNING,this);
                }
            }
        }
        this.sourceTable = newSourceTable;
        this.sourceTable.getLinkedColumns().addObjectName(this);

        if (this.getSourceColumn() == null){
           // if (attributeNode.isAttributeCreatedFromAliasColumn()){
                this.setSourceColumn(attributeNode.getSubLevelResultColumn());
           // }
        }

        this.setDbObjectTypeDirectly(EDbObjectType.column);
    }

    /**
     * Get the <b>immediate</b> source table where this column is visible in the current scope.
     *
     * <p>This returns the table/subquery/CTE that directly exposes this column in the FROM clause,
     * NOT the final physical table after tracing through subqueries or CTEs.</p>
     *
     * <p>To get the final physical table (after tracing through all layers), use:
     * {@code getResolution().getColumnSource().getFinalTable()}</p>
     *
     * <h3>Example</h3>
     * <pre>{@code
     * SELECT title FROM (SELECT * FROM books) sub
     *
     * For the 'title' column in outer SELECT:
     * - getSourceTable()           → TTable for subquery 'sub' (tableType=subquery)
     * - resolution.getFinalTable() → TTable for 'books' (the physical table)
     * }</pre>
     *
     * @return The immediate source table, or null if not resolved
     * @see #sourceTable
     * @see gudusoft.gsqlparser.resolver2.model.ColumnSource#getFinalTable()
     */
    public TTable getSourceTable() {
        // If new resolver determined this column is ambiguous, don't return old Phase 1 value
        // This ensures ambiguous columns are treated as orphan by the formatter
        // EXCEPTION: Star columns (*) should preserve their sourceTable for proper output
        if (resolution != null && resolution.isAmbiguous()) {
            String colName = getColumnNameOnly();
            if (colName != null && colName.equals("*")) {
                // Star columns keep their Phase 1 sourceTable
                return sourceTable;
            }
            if (gudusoft.gsqlparser.TBaseType.DUMP_RESOLVER_LOG_TO_CONSOLE) {
                System.out.println("[TObjectName.getSourceTable] Column '" + colName +
                    "' is AMBIGUOUS - returning null instead of " +
                    (sourceTable != null ? sourceTable.getName() : "null"));
            }
            return null;
        }
        if (resolution == null && sourceTable != null) {
            if (gudusoft.gsqlparser.TBaseType.DUMP_RESOLVER_LOG_TO_CONSOLE) {
                System.out.println("[TObjectName.getSourceTable] Column '" + getColumnNameOnly() +
                    "' has NO resolution - using Phase 1 sourceTable: " + sourceTable.getName());
            }
        }
        return sourceTable;
    }

    public void setResolveStatus(int resolveStatus) {
        this.resolveStatus = resolveStatus;

        if (this.resolveStatus == TBaseType.RESOLVED_AND_FOUND){
            this.setDbObjectTypeDirectly(EDbObjectType.column);
        }

    }

    private int resolveStatus = TBaseType.NOT_RESOLVED_YET;

    public int getResolveStatus() {
        return resolveStatus;
    }

    public void   TObjectName(){

    }

    private TObjectNameList columnAttributes = null;

    private boolean  subscripts;
    private  TIndirection indirection;

    /**
     * PostgreSQL column with array types
     * <pre>
     *     CREATE TABLE sal_emp (
     *          name            text,
     *          pay_by_quarter  integer[],
     *          schedule        text[][]
     *     );
     * </pre>
     * In the above SQL, this method returns true for <code>pay_by_quarter</code> column.
     *
     * @return true if this objectName is array type
     */
    public boolean isSubscripts() {
        return subscripts;
    }

    public void setIndirection(TIndirection indirection) {
        if(indirection == null) return;

        this.indirection = indirection;
        // setup the exceptReplaceClause of the last indirection to the parent object which is set in the .y bnf file
        if (indirection.getIndices() != null){
            if (indirection.getIndices().getElement(indirection.getIndices().size()-1).getAttributeName() != null){
                setExceptReplaceClause(indirection.getIndices().getElement(indirection.getIndices().size()-1).getAttributeName().getExceptReplaceClause());

            }
        }

        // possible syntax, support in postgresql only in current version:
        // [ indirection ], list in [] was indirection
        //
        // tablename[.column]
        // tablename[.*]
        // $1[.somecolumn]
        //
        // mytable[.arraycolumn[4]]
        // mytable[.two_d_column[17][34]]
        // $1[[10:42]]
        //

        if (this.getObjectType() == TObjectName.ttobjPositionalParameters){
            if(indirection.isRealIndices()){
                //$1[10:42]
                this.subscripts = true;
            }else{
                //$1.somecolumn
               this.setColumnTokenOfPositionalParameters(indirection.getIndices().getElement(0).getAttributeName().getPartToken());
            }
        }else{
            if(indirection.isRealIndices()){
                if (indirection.getIndices().size() == 1){
                    // arraycolumn[4]
                    this.subscripts = true;
                }else if (indirection.getIndices().size() >= 2){
                   if (!indirection.getIndices().getElement(0).isRealIndices()){
                        // mytable[.arraycolumn[4]]
                        // mytable[.two_d_column[17][34]]
                     //  this.setPartTokenOfIndirection(indirection.getIndices().getElement(0).getAttributeName().getPartToken());
                       this.subscripts = true;
                     //  this.indirection.getIndices().remove(0);
                   }
                }
            }

            //else{
                // 首先查找 : 和 [ 分隔符，如果找到，在该分隔符前的是 column，如果没有找到按照一般 qualified name 规则处理
                // https://docs.snowflake.com/en/user-guide/querying-semistructured.html
                int elementIndex = -1;
                for(int i=0;i<indirection.getIndices().size();i++){
                    TIndices tmp = indirection.getIndices().getElement(i);
                    if ((tmp.getStartToken().tokencode == ':')||(tmp.getStartToken().tokencode == '[')||(tmp.getStartToken().tokencode == TBaseType.bind_v)){
                        elementIndex = i;
                        break;
                    }
                }
                if (elementIndex >= 0){
                    // 找到了 : 和 [ 分隔符
                    if (elementIndex == 0){
                        // snowflake, <column>:<level1_element>
                        // everything already perfect, nothing need to be changed
                        partToken.setDbObjectType(EDbObjectType.column);
                    }else if (elementIndex == 1){
                        // snowflake, table.column:<level1_element>
                        objectToken = partToken;
                        objectToken.setDbObjectType(EDbObjectType.table);
                        partToken = indirection.getIndices().getElement(elementIndex-1).getAttributeName().getPartToken();
                        partToken.setDbObjectType(EDbObjectType.column);
                    }else if (elementIndex == 2){
                        // snowflake, schema.table.column:<level1_element>
                        schemaToken = partToken;
                        schemaToken.setDbObjectType(EDbObjectType.schema);
                        objectToken = indirection.getIndices().getElement(elementIndex-2).getAttributeName().getPartToken();
                        objectToken.setDbObjectType(EDbObjectType.table);
                        partToken = indirection.getIndices().getElement(elementIndex-1).getAttributeName().getPartToken();
                        partToken.setDbObjectType(EDbObjectType.column);
                    }
                }else{
                    // 一般 qualified name 规则处理
                    if (indirection.getIndices().size() == 1){
                        this.setPartTokenOfIndirection(indirection.getIndices().getElement(0).getAttributeName().getPartToken());
                    }else if (indirection.getIndices().size() == 2){
                        schemaToken = partToken;
                        schemaToken.setDbObjType(TObjectName.ttobjSchemaName);
                        objectToken = indirection.getIndices().getElement(0).getAttributeName().getPartToken();
                        objectToken.setDbObjType(ttobjTable);
                        partToken = indirection.getIndices().getElement(1).getAttributeName().getPartToken();
                        partToken.setDbObjType(ttobjColumn);
                    }else if (indirection.getIndices().size() == 3){
                        // db.schema.tablename.column
                        databaseToken = partToken;
                        databaseToken.setDbObjectType(EDbObjectType.database);
                        partToken = indirection.getIndices().getElement(2).getAttributeName().getPartToken();
                        partToken.setDbObjectType(EDbObjectType.column);
                        objectToken = indirection.getIndices().getElement(1).getAttributeName().getPartToken();
                        objectToken.setDbObjectType(EDbObjectType.table);
                        schemaToken = indirection.getIndices().getElement(0).getAttributeName().getPartToken();
                        schemaToken.setDbObjectType(EDbObjectType.schema);
                    }
                }

//                if (indirection.getIndices().size() == 1){
//                    if ((indirection.getIndices().getElement(0).getStartToken().tokencode == ':')
//                        ||(indirection.getIndices().getElement(0).getStartToken().tokencode == TBaseType.bind_v))
//                    {
//                        // snowflake, <column>:<level1_element>
//
//                    }else{
//                        // tablename[.column]
//                        // tablename[.*]
//                        this.setPartTokenOfIndirection(indirection.getIndices().getElement(0).getAttributeName().getPartToken());
//                    }
//                }else if (indirection.getIndices().size() == 2){
//                    if ((indirection.getIndices().getElement(0).getStartToken().tokencode == ':')
//                            ||(indirection.getIndices().getElement(0).getStartToken().tokencode == TBaseType.bind_v))
//                    {
//                        // snowflake, <column>:<level1_element>
//
//                    }else {
//                        // schema.tablename.column
//                        schemaToken = partToken;
//                        schemaToken.setDbObjType(TObjectName.ttobjSchemaName);
//                        objectToken = indirection.getIndices().getElement(0).getAttributeName().getPartToken();
//                        objectToken.setDbObjType(ttobjTable);
//                        partToken = indirection.getIndices().getElement(1).getAttributeName().getPartToken();
//                        partToken.setDbObjType(ttobjColumn);
//                    }
//                }else if (indirection.getIndices().size() == 3){
//                    // db.schema.tablename.column
//                    databaseToken = partToken;
//                    databaseToken.setDbObjectType(EDbObjectType.database);
//                    partToken = indirection.getIndices().getElement(2).getAttributeName().getPartToken();
//                    partToken.setDbObjectType(EDbObjectType.column);
//                    objectToken = indirection.getIndices().getElement(1).getAttributeName().getPartToken();
//                    objectToken.setDbObjectType(EDbObjectType.table);
//                    schemaToken = indirection.getIndices().getElement(0).getAttributeName().getPartToken();
//                    schemaToken.setDbObjectType(EDbObjectType.schema);
//                }

          //  }

        }

    }

    /**
     * Array element of this objectName
     * <pre>
     *     select arraycolumn[4] from t;
     * </pre>
     * In the above SQL, this method returns <code>[4]</code> of this objectName.
     *
     * @return array element of this objectName
     * @see gudusoft.gsqlparser.nodes.TIndirection
     */
    /**
     * The expressions inside the subscripts of this name, {@code arr[n]}, {@code payload.items[idx].name}: column
     * references that TSQLResolver2 and the lineage analyzer read like any other (Mantis 4817). Empty when the name
     * has no subscript.
     *
     * @return the subscript expressions, never null
     */
    public java.util.List<TExpression> getSubscriptExpressions() {
        if (indirection == null) return java.util.Collections.<TExpression>emptyList();
        return indirection.getSubscriptExpressions();
    }

    public TIndirection getIndirection() {
        return indirection;
    }

    private void setPartTokenOfIndirection(TSourceToken column){
        parseTablename();
        this.partToken = column;
        this.partToken.setDbObjType(ttobjColumn);
    }

    public void setPropertyToken(TSourceToken propertyToken) {
        this.propertyToken = propertyToken;
    }

    public TSourceToken getAtsign() {
        return atsign;
    }

    public TSourceToken getMethodToken() {

        return methodToken;
    }

    public TSourceToken getPropertyToken() {
        return propertyToken;
    }

    /**
     *  The server part of this objectName: [server.][database.][schema.]object
     *
     * @return server part of the objectName
     */
    public TSourceToken getServerToken() {
        return serverToken;
    }

    public TSourceToken getExclamationmark() {

        return exclamationmark;
    }

    /**
     *
     * The database link part <code>remoreserver</code> in this objectName: scott.emp@remoreserver
     *
     * @return database link
     */
    public TObjectName getDblink() {

        return dblink;
    }

    /**
     *  The database part of this objectName: [server.][database.][schema.]object
     *
     * @return database part of the objectName
     */
    public TSourceToken getDatabaseToken() {
        return databaseToken;
    }


    private boolean tableDetermined = true;

    public void setTableDetermined(boolean tableDetermined) {
        this.tableDetermined = tableDetermined;
    }


    /**
     * Sometime, a non-qualified column can't be linked to a table without additional metadata from database.
     * <pre>
     *     select name from emp, dept
     * </pre>
     * In the above SQL, the <code>name</code> column can't be determined which table it belongs to.
     *
     * Below is a more complicated SQL that shows the relationship between column and table.
     * <pre>
     *   select
     *          s2.s2t1a1,
     *          s3.s3t1a1
     *   from
     *       (
     *         select *
     *           from subselect2table1 s2t1
     *       ) s2,
     *       (
     *          select *
     *             from  subselect3table1, subselect3table2
     *       ) s3
     * </pre>
     *
     * column s2t1a1 was linked to subselect2table1, {@link #isTableDetermined()} returns true for this column.
     * <br> column s3t1a1 was linked to both subselect3table1 and subselect3table2
     * due to lack of meta information from database, {@link #isTableDetermined()} returns false for this column.
     * <p>
     * Provide database metadata will help GSP links the column to the table correctly.
     *
     * @return true if this column can be linked to a table without doubt.
     * @see gudusoft.gsqlparser.TGSqlParser#setMetaDatabase
     */
    public boolean isTableDetermined() {
        return tableDetermined;
    }

    /**
     * used in Oracle and teradata SQL syntax
     * <p>teradata:
     * <p>column.attribute()
     * <p>column.attribute().attribute() 
     * @param attributes
     */
    public void attributesToPropertyToken(TObjectNameList attributes){
        if (attributes.size() == 1){
            this.propertyToken = attributes.getObjectName(0).getPartToken();
        }
    }

    public void setColumnAttributes(TObjectNameList columnAttributes) {
        this.columnAttributes = columnAttributes;
    }

    /**
     * The data type of this column is structured UDT, this method returns the column's attributes.
     * Below is the sample SQL from <a href="https://info.teradata.com/HTMLPubs/DB_TTU_16_00/index.html#page/SQL_Reference/B035-1146-160K/fyj1472240813334.html">teradata</a>.
     * <pre>
     *
     *          CREATE TYPE school_record AS (
     *           school_name VARCHAR(20),
     *           GPA         FLOAT);
     *
     *          CREATE TYPE college_record AS (
     *           school school_record,
     *           major  VARCHAR(20),
     *           minor  VARCHAR(20));
     *
     *          CREATE TABLE student_record (
     *           student_id  INTEGER,
     *           Last_name   VARCHAR(20),
     *           First_name  VARCHAR(20),
     *           high_school school_record,
     *           college     college_record);
     *
     *          SELECT student_id, last_name, first_name,
     *           high_school.school_name(), high_school.GPA(),
     *           college.school().school_name(), college.school().GPA(),
     *           college.major(), college.minor()
     *          FROM student_record;
     *
     *          SELECT *.ALL FROM student_record;
     *          SELECT student_record.*.ALL;
     * </pre>
     * Take this column <code>college.school().school_name()</code> for example, the partToken of this objectName
     * should be <code>college</code>, and the value returned by this method should be
     * <code>school().school_name()</code>
     * <p>
     * PLEASE NOTE THAT CURRENT VERSION CAN'T HANDLE THE ABOVE SQL CORRECTLY.
     *
     * @return attributes of this structured UDT column
     */
    public TObjectNameList getColumnAttributes() {
        return columnAttributes;
    }

    /**
     * Used internally.
     * @deprecated use {@link #setDbObjectType} instead
     *
     * @param objectType object type of this objectName
     */
    public void setObjectType(int objectType) {
        if (this.objectType == objectType) return;
        this.objectType = objectType;
        // set this object type to source token
        switch(this.getObjectType()){
            case TObjectName.ttobjTable:
           // case TObjectName.ttobjTableTemp:
            //    case TObjectName.ttobjTableVar:
                this.parseTablename();
                this.objectToken.setDbObjType(this.objectType);
                if (dbObjectType != EDbObjectType.stage){ // not already set to stage
                    dbObjectType = EDbObjectType.table;
                }

                if ((!TSQLEnv.supportSchema(this.dbvendor))&&(this.schemaToken != null)){
                    this.databaseToken = this.schemaToken;
                    this.schemaToken = null;
                }
                break;
//            case TObjectName.ttobjTableCTE:
//                this.parseTablename();
//                this.objectToken.setDbObjType(this.objectType);
//                dbObjectType = EDbObjectType.cte;
//                break;
//            case ttObjLibrary:
//                this.parseTablename();
//                this.objectToken.setDbObjType(this.objectType);
//                dbObjectType = EDbObjectType.library;
//                break;
            case TObjectName.ttobjColumn:
                this.partToken.setDbObjType(this.objectType);
                // Through the shared downgrade, not a bare assignment: the
                // legacy resolver reaches the classification here rather than
                // via setDbObjectType(), and a bare write made ROWID report
                // `column` under EResolverType.RESOLVER while every other
                // resolver said notAColumn (Mantis #4675).
                dbObjectType = downgradeOracleTableScopedPseudoColumn(EDbObjectType.column);
                break;
            case TObjectName.ttobjColumnAlias:
                if ((this.objectToken == null) && (this.partToken != null)){
                   this.parseObjectName();
                }
                this.objectToken.setDbObjType(this.objectType);
                dbObjectType = EDbObjectType.column_alias;
                break;
//            case TObjectName.ttObjTableAlias:
//                this.parseObjectName();
//                this.objectToken.setDbObjType(this.objectType);
//                dbObjectType = EDbObjectType.table_alias;
//                break;
            case TObjectName.ttobjParameter:
                this.parseObjectName();
                this.objectToken.setDbObjType(this.objectType);
                dbObjectType = EDbObjectType.parameter;
                break;
            case TObjectName.ttobjVariable:
                this.parseVariableName();
                this.objectToken.setDbObjType(this.objectType);
                dbObjectType = EDbObjectType.variable;
                break;
            case TObjectName.ttobjColumnMethod:
                if (dbObjectType != EDbObjectType.method){
                    this.parseColumnMethodName();
                    this.partToken.setDbObjType(this.ttobjColumn);
                    this.methodToken.setDbObjType(this.ttobjColumnMethod);
                    dbObjectType = EDbObjectType.method;
                }
                break;
//            case TObjectName.ttobjProcedureName:
//                this.parseFunctionName();
//                this.objectToken.setDbObjType(this.objectType);
//                dbObjectType = EDbObjectType.procedure;
//                break;
            case TObjectName.ttobjFunctionName:
                this.parseFunctionName();
                this.objectToken.setDbObjType(this.objectType);
                dbObjectType = EDbObjectType.function;
                break;
//            case TObjectName.ttobjLabelName:
//                this.parseObjectName();
//                this.objectToken.setDbObjType(this.objectType);
//                dbObjectType = EDbObjectType.label;
//                break;
//            case TObjectName.ttobjIndexName:
//                this.parseObjectName();
//                this.objectToken.setDbObjType(this.objectType);
//                dbObjectType = EDbObjectType.index;
//                break;
//            case TObjectName.ttobjMaterializedViewName:
//                this.parseObjectName();
//                this.objectToken.setDbObjType(this.objectType);
//                dbObjectType = EDbObjectType.materializedView;
//                break;
//            case TObjectName.ttobjViewName:
//                this.parseObjectName();
//                this.objectToken.setDbObjType(this.objectType);
//                dbObjectType = EDbObjectType.view;
//                break;
//            case TObjectName.ttobjCursorName:
//                this.parseObjectName();
//                this.objectToken.setDbObjType(this.objectType);
//                dbObjectType = EDbObjectType.cursor;
//                break;
            case TObjectName.ttobjConstraintName:
                this.parseObjectName();
                this.objectToken.setDbObjType(this.objectType);
                dbObjectType = EDbObjectType.constraint;
                break;
//            case TObjectName.ttobjPropertyName:
//                this.propertyToken.setDbObjType(this.objectType);
//                dbObjectType = EDbObjectType.property;
//                break;
//            case TObjectName.ttobjTransactionName:
//                this.parseObjectName();
//                this.objectToken.setDbObjType(this.objectType);
//                dbObjectType = EDbObjectType.transaction;
//                break;
//            case TObjectName.ttobjDatabaseName:
//                this.parseObjectName();
//                this.objectToken.setDbObjType(this.objectType);
//                dbObjectType = EDbObjectType.database;
//                break;
            case TObjectName.ttobjStringConstant:
                this.parseObjectName();
                this.objectToken.setDbObjType(this.objectType);
                break;
//            case TObjectName.ttobjAliasName:
//                this.parseObjectName();
//                this.objectToken.setDbObjType(this.objectType);
//                dbObjectType = EDbObjectType.alias;
//                break;
            case TObjectName.ttobjAttribute:
                this.partToken.setDbObjType(this.objectType);
                dbObjectType = EDbObjectType.attribute;
                break;

            case TObjectName.ttobjPositionalParameters:
                dbObjectType = EDbObjectType.parameter;
                break;
//           case TObjectName.ttobjTypeName:
//               this.parseObjectName();
//               this.objectToken.setDbObjType(this.objectType);
//               dbObjectType = EDbObjectType.user_defined_type;
//               break;
//            case TObjectName.ttobjPackage:
//                this.parseObjectName();
//                this.objectToken.setDbObjType(this.objectType);
//                dbObjectType = EDbObjectType.plsql_package;
//                break;
//            case TObjectName.ttobjSequence:
//                this.parseObjectName();
//                this.objectToken.setDbObjType(this.objectType);
//                dbObjectType = EDbObjectType.sequence;
//                break;
//            case TObjectName.ttobjTrigger:
//                this.parseObjectName();
//                this.objectToken.setDbObjType(this.objectType);
//                dbObjectType = EDbObjectType.trigger;
//                break;
            default:
                break;
        }
    }

    public void setDbObjectType(EDbVendor dbVendor, EDbObjectType dbObjectType) {
        this.dbvendor = dbVendor;
        this.setDbObjectType(dbObjectType);
    }

    public void setDbObjectTypeDirectly(EDbObjectType dbObjectType) {
        // A table-scoped Oracle pseudocolumn (ROWID) can never be a column of
        // the table it is linked to - the name is an Oracle reserved word, so
        // no table has a column called that. Several unrelated setters
        // (setSourceTable, setSourceColumn, setColumnsLinkedToStar,
        // setResolveStatus, ...) force the type to column as a side effect, and
        // each resolver goes through a different one of them, so the answer used
        // to depend on which resolver ran. Catching it here is what makes the
        // classification resolver-independent (Mantis #4675).
        this.dbObjectType = downgradeOracleTableScopedPseudoColumn(dbObjectType);
    }

    /**
     * Substitutes {@link EDbObjectType#notAColumn} for {@link EDbObjectType#column}
     * when this name is a table-scoped Oracle pseudocolumn, i.e. ROWID.
     *
     * <p>ROWID keeps the table it was linked to - the row really did come from
     * there - but must not be reported as a column of it, because ROWID is an
     * Oracle reserved word and no table has a column by that name. Several
     * unrelated setters force the type to column as a side effect
     * (setSourceTable, setSourceColumn, setColumnsLinkedToStar,
     * setResolveStatus, ...), and each resolver reaches a different one, so
     * without a shared downgrade the answer depended on which resolver ran -
     * the legacy RESOLVER returned column while DEFAULT and RESOLVER2 returned
     * notAColumn once catalog metadata was supplied (Mantis #4675).</p>
     *
     * <p>Note this deliberately does NOT consult {@code getQuoteType()}, which
     * reports the FIRST segment's quote state; for {@code "t".ROWID} that is
     * the alias. {@code getColumnNameOnly()} carries the terminal segment's own
     * quotes, so a quoted {@code "ROWID"} simply fails to match.</p>
     */
    private EDbObjectType downgradeOracleTableScopedPseudoColumn(EDbObjectType requested) {
        if (requested != EDbObjectType.column) return requested;
        if (this.dbvendor != EDbVendor.dbvoracle) return requested;
        if (!OraclePseudoColumnUtil.isTableScopedPseudoColumn(getColumnNameOnly())) return requested;
        return EDbObjectType.notAColumn;
    }
    /**
     * Set object type of this objectName
     *
     * @param dbObjectType database object type
     */
    public void setDbObjectType(EDbObjectType dbObjectType) {
        if (this.dbObjectType == dbObjectType) return;
        if (this.dbObjectType == EDbObjectType.stage) return;
        // TODO, 如果已经被设定为某个对象类型，不应该再次设置，但如果下面的语句执行，会导致部分测试用例失败，需要查具体原因
        // if (this.dbObjectType != EDbObjectType.unknown) return;

        EDbObjectType prev = this.dbObjectType;
        // Only the stored type is downgraded; the switch below still runs on
        // the requested type so parseColumnName() and friends are unaffected.
        this.dbObjectType = downgradeOracleTableScopedPseudoColumn(dbObjectType);
        if (prev == EDbObjectType.unknown){
            switch (dbObjectType){
                case column:
                    parseColumnName();
                    break;
                case table:
                case index:
                case synonym:
                case macro:
                case view:
                case stage:
                case task:
                case stream:
                case TEMP_TABLE:
                case pipe:
                case security_policy:

                case plsql_package:
                case trigger:
                case transaction:
                case user_defined_type:
                case property:
                case cursor:
                case label:
                case table_alias:
                case partitionScheme:
                    parseTablename();
                    break;
                case library:
                    parseTablename();
                    break;
                case function:
                    parseFunctionName();
                    break;
                case procedure:
                case materializedView:
                    parseFunctionName();
                    break;
                case alias:
                case module:
                case sequence:
                    parseTablename();
                    break;
                case database:
                    this.objectToken = this.partToken;
                    this.databaseToken = null;
                    this.partToken = null;
                    break;
                case variable:
                    parseVariableName();
                    break;
                case schema:
                    this.databaseToken = this.objectToken;
                    this.objectToken = this.partToken;
                    this.schemaToken = this.partToken;
                    break;
                case method:
                    this.parseColumnMethodName();
                    this.partToken.setDbObjType(this.ttobjColumn);
                    //this.methodToken.setDbObjType(this.ttobjColumnMethod);
                    this.methodToken.setDbObjectType(EDbObjectType.method);
                    break;
                case cte:
                    parseObjectName();
                    break;
                case hint: //sql server hint like nolock
                    parseObjectName();
                    break;
                default:
                    break;
            }
        }
    }

    private EDbObjectType dbObjectType = EDbObjectType.unknown;

    /**
     * The database object type of this objectName such as table, view, column for example.
     * If object type is {@link gudusoft.gsqlparser.EDbObjectType#column}, {@link #getPartToken} represents
     * the column name, for all other object type, the name of this database object is stored in {@link #getObjectToken}
     *
     * @return database object type
     */
    public EDbObjectType getDbObjectType() {
        return dbObjectType;
    }

    /**
     * @deprecated use {@link #getDbObjectType()} instead.
     *
     * @return the type of database object or variable this objectName represents for.
     */
    public int getObjectType() {

        return objectType;
    }


    public void setAtsign(TSourceToken atsign) {
        this.atsign = atsign;
    }

    public void setDblink(TObjectName dblink) {
        dblink.setDbObjectType(EDbObjectType.dblink);
        this.dblink = dblink;
    }

    public void setDblink(TObjectName dblink, boolean linkToDB) {
        setDblink(dblink);

        if (linkToDB){
            if (dblink.numberOfPart == 1){
                this.databaseToken = dblink.getPartToken();
            }
        }
    }

    private TSourceToken serverToken = null; //sql server
    private TSourceToken databaseToken = null; //sql server
    // schemaToken.objectToken.partToken@dblink, schemaToken, partToken, and dblink is optional
    private TSourceToken schemaToken;
    private TSourceToken objectToken;

    /*
     * part is a part of the object. This identifier lets you refer to a part of a schema object,
     * such as a column or a partition of a table. Not all types of objects have parts.
     */
    private TSourceToken partToken;
    private TSourceToken propertyToken = null;
    private TSourceToken methodToken = null;
    private TSourceToken atsign; //@
    private TObjectName dblink;

    // Additional parts for deeply nested struct field access (BigQuery, etc.)
    // Stores parts beyond the 6 standard tokens (server, database, schema, object, part, property)
    private java.util.List<TSourceToken> additionalParts = null;

    // ===== Phase 5: Normalized identifier cache (transient, not serialized) =====
    // These caches reduce repeated normalize() calls for the same TObjectName
    private transient String normalizedServer;
    private transient String normalizedDatabase;
    private transient String normalizedSchema;
    private transient String normalizedTable;
    private transient String normalizedColumn;
    private transient long cacheFingerprint = 0;  // Profile fingerprint for cache invalidation

    public void setServerToken(TSourceToken serverToken) {
        this.serverToken = serverToken;
    }

    public void setDatabaseToken(TSourceToken databaseToken, boolean implicit) {
        this.isImplicitDatabase = implicit;
        setDatabaseToken(databaseToken);
    }

    public void setDatabaseToken(TSourceToken databaseToken) {
        this.databaseToken = databaseToken;
    }

    public void setObjectToken(TSourceToken objectToken) {
        this.objectToken = objectToken;
    }

    public void setPartToken(TSourceToken partToken) {
        this.partToken = partToken;
    }

    public void setMethodToken(TSourceToken methodToken) {
        this.methodToken = methodToken;
    }

    public void setSchemaToken(TSourceToken schemaToken, boolean implicit) {
        this.isImplicitSchema = implicit;
        setSchemaToken(schemaToken);
    }

    public void setSchemaToken(TSourceToken schemaToken) {

        this.schemaToken = schemaToken;
    }

    public void setPackageToken(TSourceToken packageToken) {
        this.packageToken = packageToken;
    }

    /**
     * Oracle package name
     *
     * @return the source token of Oracle package name.
     */
    public TSourceToken getPackageToken() {
        return packageToken;
    }

    private TSourceToken packageToken = null;


    /**
     * The object part of this objectName such as table name, view name.
     *
     * @return object part of this objectName
     */
    public TSourceToken getObjectToken() {
        return objectToken;
    }

    /**
     * The column name of this objectName if {@link #getDbObjectType} is {@link EDbObjectType#column}.
     * {@link #getColumnToken} returns the same value.
     *
     * @return the column name
     */
    public TSourceToken getPartToken() {
        return partToken;
    }

    /**
     * The schema name of this objectName.
     *
     * @return schema name
     */
    public TSourceToken getSchemaToken() {
        return schemaToken;
    }


    private String schemaString;
    private String objectString;
    private String partString;

    /**
     * String text of the package name.
     *
     * @return string of the package name,return null if empty.
     */
    public String getPackageString(){
        if (getPackageToken() != null) return  getPackageToken().toString();
        else return "";
    }

    /**
     * String text of the server name
     *
     * @return string of the server name,return null if empty.
     */
    public String getServerString(){
        if (getServerToken() != null) return  getServerToken().toString();
        else return "";
    }

    /**
     * String text of the database name
     *
     * @return string of the database name,return null if empty.
     */
    public String getDatabaseString(){
        if (isImplicitDatabase ) return "";
        else if (getDatabaseToken() != null) return getDatabaseToken().toString();
        else if ((this.dbObjectType == EDbObjectType.database) && (getObjectToken() != null)){
            return getObjectToken().toString();
        }
        else return "";
    }

    /**
     * String text of schema name in a qualified name of a schema object.
     *
     *
     * @return string of schema name, return null if empty.
     */
    public String getSchemaString() {
        if (isImplicitSchema) return "";
        else if (schemaToken != null)
            return schemaToken.getAstext();
        else
            return "" ;
    }

    private TSQLEnv sqlEnv = null;

    public void setSqlEnv(TSQLEnv sqlEnv) {
        this.sqlEnv = sqlEnv;
    }



    /**
     * This is the schema fetched from the SQLEnv. Not the direct qualified schema name of this object
     * search this table in the current default database and schema.
     *
     * If this is a qualified schema object, then return {@link #getSchemaString()}
     *
     * This method is only valid when the {@link #dbObjectType} is a schema object.
     *
     * @return schema name fetched from the SQLEnv
     */
    public String getImplictSchemaString() {
        String implictSchema = null;
        // Objects with a db_link refer to remote databases and should not
        // inherit the current session's default schema
        if (this.dblink != null) return null;
        if (this.implictSchemaName != null) return this.implictSchemaName;

        if (schemaToken != null) return schemaToken.toString();
        if (getSchemaString().length() > 0) return  getSchemaString();

        if (sqlEnv == null) return null;

        TSQLSchema s = searchImplicitSchema();
        if (s != null){
            implictSchema = s.getName();
        }

        return implictSchema;
    }

    /**
     * Where the text of {@link #getImplictSchemaString()} came from, so a consumer can key it:
     * {@link gudusoft.gsqlparser.sqlenv.IdentifierInputForm#CATALOG_STORED} when the name was found by
     * searching the catalog and the text is the schema the catalog holds it in ({@code TSQLSchema.getName()}),
     * {@link gudusoft.gsqlparser.sqlenv.IdentifierInputForm#SQL_LEXICAL} when it is a spelling: the name's
     * own qualifier, or a session default a resolver stamped, which the catalog itself reads as SQL.
     * On PostgreSQL the two read {@code Mixed} as different schemas.
     *
     * @return null when {@link #getImplictSchemaString()} has no value
     */
    public gudusoft.gsqlparser.sqlenv.IdentifierInputForm getImplictSchemaForm() {
        if (this.dblink != null) return null;
        if (this.implictSchemaName != null || schemaToken != null || getSchemaString().length() > 0) {
            return gudusoft.gsqlparser.sqlenv.IdentifierInputForm.SQL_LEXICAL;
        }
        if (sqlEnv == null) return null;
        return searchImplicitSchema() != null ? gudusoft.gsqlparser.sqlenv.IdentifierInputForm.CATALOG_STORED : null;
    }

    /**
     * Where the text of {@link #getImplictDatabaseString()} came from; see {@link #getImplictSchemaForm()}.
     *
     * @return null when {@link #getImplictDatabaseString()} has no value
     */
    public gudusoft.gsqlparser.sqlenv.IdentifierInputForm getImplictDatabaseForm() {
        if (this.dblink != null) return null;
        if (implictDatabaseName != null || getDatabaseString().length() > 0) {
            return gudusoft.gsqlparser.sqlenv.IdentifierInputForm.SQL_LEXICAL;
        }
        if (sqlEnv == null) return null;
        TSQLSchema s = searchImplicitSchema();
        return s != null && s.getCatalog() != null ? gudusoft.gsqlparser.sqlenv.IdentifierInputForm.CATALOG_STORED : null;
    }

    private String implictDatabaseName;
    private String implictSchemaName;

    public void setImplictDatabaseName(String implictDatabaseName) {
        this.isImplicitDatabase = true;
        this.implictDatabaseName = implictDatabaseName;
    }

    public void setImplictSchemaName(String implictSchemaName) {
        this.isImplicitSchema = true;
        this.implictSchemaName = implictSchemaName;
    }

    public String getImplictDatabaseString() {
        String implictDatabase = null;
        // Objects with a db_link refer to remote databases and should not
        // inherit the current session's default catalog
        if (this.dblink != null) return null;
        if (implictDatabaseName != null) return implictDatabaseName;

        if (getDatabaseString().length() > 0) return  getDatabaseString();

        if (sqlEnv == null) return null;
        TSQLSchema s = searchImplicitSchema();
        if (s != null){
            TSQLCatalog c = s.getCatalog();
            if (c != null){
                implictDatabase = c.getName();
            }
        }

        return implictDatabase;
    }

    protected TSQLSchema searchImplicitSchema(){
        TSQLSchema s = null;
        if (sqlEnv == null) return null;
        switch (dbObjectType){
            case table:
            case view:
                TSQLTable t = sqlEnv.searchTable(".."+this.getObjectString());
                if (t != null){
                    s = t.getSchema();
                }

                break;
            case function:
            case procedure:
                TSQLFunction f = sqlEnv.searchFunction(".."+this.getObjectString());
                if (f != null){
                    s = f.getSchema();
                }
                break;
            default:
                break;
        }

        return s;
    }

    /**
     * The table name of this objectName, it's the same value as {@link #getObjectToken} if {@link #getDbObjectType}
     * is {@link gudusoft.gsqlparser.EDbObjectType#table}
     *
     * @return table name
     */
    public  TSourceToken getTableToken(){
        if (objectToken == null) return  null;
        else return objectToken;
    }

    /**
     * String text of the table name.
     *
     * <p><b>Note on the returned value</b>: for a qualified column
     * reference like {@code c.sbCustId} in {@code FROM sbCustomer c},
     * this returns the <em>user-written qualifier</em> {@code "c"} (the
     * alias), not the resolved physical table {@code "sbCustomer"}. The
     * method does not disambiguate alias from table name — it returns
     * whatever literal appears before the dot in the source SQL. For
     * the resolved physical table, use {@link #getSourceTable()} and
     * read {@code TTable.getName()} on the result; that goes through
     * the two-phase semantic resolver which performs the alias → table
     * mapping. See <a href="https://www.sqlparser.com/bugs/mantisbt/view.php?id=4464">MantisBT
     * #4464</a> — a dedicated convenience accessor
     * {@code getResolvedTableName()} is proposed in that ticket to make
     * the resolved-table use case more discoverable; it will be added
     * additively without changing this method's behavior or signature.
     *
     * @return string of the table name, return null if empty.
     * @see #getSourceTable()
     */
    public String getTableString(){
        if (objectToken == null) return  "";
//        else if (!((dbObjectType == EDbObjectType.table)||(dbObjectType == EDbObjectType.view))){
//            return "";
//        }
        else return objectToken.toString();
    }

    /**
     * String text of the object name
     *
     * @return string of the object name, return null if empty.
     */
    public String getObjectString() {
        if (objectToken != null)
            return objectToken.getAstext();
        else
            return "" ;
    }

    /**
     * String text of the part name
     *
     * @return string of the part name, return null if empty.
     */
    public String getPartString() {
        if (partToken != null)
            return partToken.getAstext();
        else
            return "" ;
    }

    // ===== Phase 5: Cached normalized getters (reduce repeated normalize() calls) =====

    private transient gudusoft.gsqlparser.sqlenv.IdentifierService identifierService;

    /**
     * Lazy initialization of IdentifierService for normalized identifier caching
     */
    private gudusoft.gsqlparser.sqlenv.IdentifierService getIdentifierService() {
        if (identifierService == null && sqlEnv != null) {
            gudusoft.gsqlparser.sqlenv.IdentifierProfile profile = gudusoft.gsqlparser.sqlenv.IdentifierProfile.forVendor(
                sqlEnv.getDBVendor(),
                gudusoft.gsqlparser.sqlenv.IdentifierProfile.VendorFlags.defaults()
            );
            identifierService = new gudusoft.gsqlparser.sqlenv.IdentifierService(profile, null);
        }
        return identifierService;
    }

    /**
     * Get normalized database string with caching (Phase 5 optimization).
     *
     * <p>This method caches the normalized database name to avoid repeated normalize() calls.
     * The cache is invalidated automatically when the IdentifierProfile changes (e.g., vendor switch).
     *
     * @return normalized database name, or empty string if not available
     */
    public String getNormalizedDatabaseString() {
        if (sqlEnv == null) return getDatabaseString();

        try {
            gudusoft.gsqlparser.sqlenv.IdentifierService service = getIdentifierService();
            if (service == null) return getDatabaseString();

            long currentFingerprint = service.getProfile().getFingerprint();

            // Check if cache is valid (not null and fingerprint matches)
            if (normalizedDatabase == null || cacheFingerprint != currentFingerprint) {
                String raw = getDatabaseString();
                if (raw != null && !raw.isEmpty()) {
                    normalizedDatabase = service.normalize(raw, gudusoft.gsqlparser.sqlenv.ESQLDataObjectType.dotCatalog);
                } else {
                    normalizedDatabase = "";
                }
                cacheFingerprint = currentFingerprint;
            }

            return normalizedDatabase;
        } catch (Throwable t) {
            // Fallback to non-cached on any error
            return getDatabaseString();
        }
    }

    /**
     * Get normalized schema string with caching (Phase 5 optimization).
     *
     * <p>This method caches the normalized schema name to avoid repeated normalize() calls.
     * The cache is invalidated automatically when the IdentifierProfile changes.
     *
     * @return normalized schema name, or empty string if not available
     */
    public String getNormalizedSchemaString() {
        if (sqlEnv == null) return getSchemaString();

        try {
            gudusoft.gsqlparser.sqlenv.IdentifierService service = getIdentifierService();
            if (service == null) return getSchemaString();

            long currentFingerprint = service.getProfile().getFingerprint();

            // Check if cache is valid
            if (normalizedSchema == null || cacheFingerprint != currentFingerprint) {
                String raw = getSchemaString();
                if (raw != null && !raw.isEmpty()) {
                    normalizedSchema = service.normalize(raw, gudusoft.gsqlparser.sqlenv.ESQLDataObjectType.dotSchema);
                } else {
                    normalizedSchema = "";
                }
                cacheFingerprint = currentFingerprint;
            }

            return normalizedSchema;
        } catch (Throwable t) {
            // Fallback to non-cached
            return getSchemaString();
        }
    }

    /**
     * Get normalized table string with caching (Phase 5 optimization).
     *
     * <p>This method caches the normalized table name to avoid repeated normalize() calls.
     * The cache is invalidated automatically when the IdentifierProfile changes.
     *
     * @return normalized table name, or empty string if not available
     */
    public String getNormalizedTableString() {
        if (sqlEnv == null) return getTableString();

        try {
            gudusoft.gsqlparser.sqlenv.IdentifierService service = getIdentifierService();
            if (service == null) return getTableString();

            long currentFingerprint = service.getProfile().getFingerprint();

            // Check if cache is valid
            if (normalizedTable == null || cacheFingerprint != currentFingerprint) {
                String raw = getTableString();
                if (raw != null && !raw.isEmpty()) {
                    normalizedTable = service.normalize(raw, gudusoft.gsqlparser.sqlenv.ESQLDataObjectType.dotTable);
                } else {
                    normalizedTable = "";
                }
                cacheFingerprint = currentFingerprint;
            }

            return normalizedTable;
        } catch (Throwable t) {
            // Fallback to non-cached
            return getTableString();
        }
    }

    /**
     * Get normalized column string with caching (Phase 5 optimization).
     *
     * <p>This method caches the normalized column name (from partToken) to avoid repeated normalize() calls.
     * The cache is invalidated automatically when the IdentifierProfile changes.
     *
     * @return normalized column name, or empty string if not available
     */
    public String getNormalizedColumnString() {
        if (sqlEnv == null) return getPartString();

        try {
            gudusoft.gsqlparser.sqlenv.IdentifierService service = getIdentifierService();
            if (service == null) return getPartString();

            long currentFingerprint = service.getProfile().getFingerprint();

            // Check if cache is valid
            if (normalizedColumn == null || cacheFingerprint != currentFingerprint) {
                String raw = getPartString();
                if (raw != null && !raw.isEmpty()) {
                    normalizedColumn = service.normalize(raw, gudusoft.gsqlparser.sqlenv.ESQLDataObjectType.dotColumn);
                } else {
                    normalizedColumn = "";
                }
                cacheFingerprint = currentFingerprint;
            }

            return normalizedColumn;
        } catch (Throwable t) {
            // Fallback to non-cached
            return getPartString();
        }
    }

    /**
     * Get normalized server string with caching (Phase 5 optimization).
     *
     * <p>This method caches the normalized server name to avoid repeated normalize() calls.
     * The cache is invalidated automatically when the IdentifierProfile changes.
     *
     * @return normalized server name, or empty string if not available
     */
    public String getNormalizedServerString() {
        if (sqlEnv == null) return getServerString();

        try {
            gudusoft.gsqlparser.sqlenv.IdentifierService service = getIdentifierService();
            if (service == null) return getServerString();

            long currentFingerprint = service.getProfile().getFingerprint();

            // Check if cache is valid
            if (normalizedServer == null || cacheFingerprint != currentFingerprint) {
                String raw = getServerString();
                if (raw != null && !raw.isEmpty()) {
                    // Use dotUnknown for server since there's no dotServer type
                    normalizedServer = service.normalize(raw, gudusoft.gsqlparser.sqlenv.ESQLDataObjectType.dotUnknown);
                } else {
                    normalizedServer = "";
                }
                cacheFingerprint = currentFingerprint;
            }

            return normalizedServer;
        } catch (Throwable t) {
            // Fallback to non-cached
            return getServerString();
        }
    }


    public void setExclamationmark(TSourceToken exclamationmark) {
        this.exclamationmark = exclamationmark;
    }

    private TSourceToken exclamationmark; // objectToken@!, ! is dblink

    private Boolean isParsed = false;

    private void parseObjectName(){
        parseTablename();
    }

   private void parseTablename(){
       if ((this.dbObjectType == EDbObjectType.variable) ||(this.dbObjectType == EDbObjectType.stage))return;

       switch (this.dbvendor){
           case dbvteradata:
           case dbvhive:
               if (objectToken != null){
                   databaseToken = objectToken;
                   //databaseToken.setDbObjType(TObjectName.ttobjDatabaseName);
                   databaseToken.setDbObjectType(EDbObjectType.database);
                   schemaToken = objectToken;
               }
               objectToken = partToken;
               partToken = null;

               break;
           default:
               if (databaseToken != null){
                   serverToken = databaseToken;
                   //serverToken.setDbObjType(TObjectName.ttobjServerName);
                   serverToken.setDbObjectType(EDbObjectType.server);
               }

               if (schemaToken != null){
                   databaseToken = schemaToken;
                   //databaseToken.setDbObjType(TObjectName.ttobjDatabaseName);
                   databaseToken.setDbObjectType(EDbObjectType.database);
               }

               if (objectToken != null){
                   schemaToken = objectToken;
                   schemaToken.setDbObjType(TObjectName.ttobjSchemaName);
               }

               objectToken = partToken;
               partToken = null;
               break;
       }

       if (objectToken != null){
           objectToken.setDbObjectType(this.dbObjectType);
       }
    }

    private void parseVariableName(){
        if (databaseToken != null){
            serverToken = databaseToken;
            //serverToken.setDbObjType(TObjectName.ttobjServerName);
            serverToken.setDbObjectType(EDbObjectType.server);
        }

        if (schemaToken != null){
            databaseToken = schemaToken;
           // databaseToken.setDbObjType(TObjectName.ttobjDatabaseName);
            databaseToken.setDbObjectType(EDbObjectType.database);
        }

        if (objectToken != null){
            if (partToken != null){
                schemaToken = objectToken;
                schemaToken.setDbObjType(TObjectName.ttobjSchemaName);
                objectToken = partToken;
                partToken = null;
            }else{

            }
        }else{
            objectToken = partToken;
            partToken = null;
        }
    }

    private String ansiSchemaName;
    private String ansiCatalogName;


    /**
     *  In this SQL: select * from part1.part2,
     *  In Hive, MySQL and Teradata, part1 will be treated as a database name, returned in getDatabaseString(),
     *  while getSchemaString() return empty string.
     *
     *  However, TObjectName.getAnsiSchemaName() will return part1, which means it's a schema name.
     *
     *  If a table name is not qualified with a schema name, but GSP detect the schema for this table in the metadata
     *  then, this method will return this detected schema name.
     *
     * @return schema name
     */
    public String getAnsiSchemaName(){
        String ret = this.getSchemaString();
        if ((ret.length() == 0) && ((this.getImplictSchemaString() != null) && (!this.getImplictSchemaString().equalsIgnoreCase("default")))){
            ret = this.getImplictSchemaString();
        }

        switch (dbvendor){
            case dbvmysql:
            case dbvhive:
            case dbvteradata:
            case dbvimpala:
                ret = this.getDatabaseString();
                break;
        }
        return ret;
    }

    /**
     *   If a table name is not qualified with a database name, but GSP detect the database  for this table in the metadata
     *   then, this method will return this detected database name.
     *
     * @return
     */
    public String getAnsiCatalogName(){
        String ret = this.getDatabaseString();
        if (( ret.length() == 0) && (this.getImplictDatabaseString() != null) && (!this.getImplictDatabaseString().equalsIgnoreCase("default"))){
            ret = this.getImplictDatabaseString();
        }

        switch (dbvendor){
            case dbvmysql:
            case dbvhive:
            case dbvteradata:
            case dbvimpala:
                ret = "";
                break;
        }

        return  ret;
    }

    private void parseFunctionName(){
        this.parseTablename();
     }

    private void parseColumnMethodName(){
       // objectType = ttobjColumnMethod;

        methodToken = objectToken;
        partToken = schemaToken;

        objectToken = null;//;
        schemaToken = null;
     }

    private void parseColumnName(){
        assert(partToken != null);
     }

    public TObjectName(){
    }

    /**
     *  List the number of parts made up this objectName
     *
     * @return the number of parts that made up this objectName
     */
    public int getNumberOfPart() {
        return numberOfPart;
    }

    private int numberOfPart = 1;

    public static TObjectName createObjectName(EDbVendor dbVendor, EDbObjectType dbObjectType){
        return new TObjectName(dbVendor,dbObjectType);
    }


    public static TObjectName createObjectName(EDbVendor dbVendor, EDbObjectType dbObjectType,TSourceToken token1){
        return new TObjectName(dbVendor,dbObjectType,token1);
    }

    public static TObjectName createObjectName(EDbVendor dbVendor, EDbObjectType dbObjectType, String str) {
        String[] parts = str.split("\\.");
        if (parts.length == 1) {
            return new TObjectName(dbVendor, dbObjectType, new TSourceToken(parts[0]));
        } else if (parts.length == 2) {
            return new TObjectName(dbVendor, dbObjectType, new TSourceToken(parts[0]), new TSourceToken(parts[1]));
        } else if (parts.length == 3) {
            return new TObjectName(dbVendor, dbObjectType, new TSourceToken(parts[0]), new TSourceToken(parts[1]), new TSourceToken(parts[2]));
        } else if (parts.length == 4) {
            return new TObjectName(dbVendor, dbObjectType, new TSourceToken(parts[0]), new TSourceToken(parts[1]), new TSourceToken(parts[2]), new TSourceToken(parts[3]));
        }
        return new TObjectName(dbVendor, dbObjectType, new TSourceToken(str));
    }


    public static TObjectName createObjectName(EDbVendor dbVendor, EDbObjectType dbObjectType,TSourceToken token1,TSourceToken token2){
        return new TObjectName(dbVendor,dbObjectType,token1,token2);
    }

    public static TObjectName createObjectName(EDbVendor dbVendor, EDbObjectType dbObjectType,TSourceToken token1,TSourceToken token2,TSourceToken token3){
        return new TObjectName(dbVendor,dbObjectType,token1,token2,token3);
    }

    public static TObjectName createObjectName(EDbVendor dbVendor, EDbObjectType dbObjectType,TSourceToken token1,TSourceToken token2,TSourceToken token3,TSourceToken token4){
        return new TObjectName(dbVendor,dbObjectType,token1,token2,token3,token4);
    }

    /**
     * @deprecated As of v2.0.7.1, please use {@link #TObjectName(EDbObjectType, TSourceToken)} instead.
     *
     * Class constructor specifying object name and object type.
     * <p>
     * Use {@link gudusoft.gsqlparser.TGSqlParser#parseObjectName} to create an objectName more than 2 parts.
     *
     * @param token           name of this object
     * @param dbObjectType   type of this object
     */
    private TObjectName(TSourceToken token,EDbObjectType dbObjectType){
        this(dbObjectType,token);
    }

    public void splitNameInQuotedIdentifier(){
        if (this.dbvendor != EDbVendor.dbvbigquery && this.dbvendor != EDbVendor.dbvsnowflake) return;
        if (this.objectToken == null) return;
        TSourceToken token = this.objectToken;

        // For Snowflake IDENTIFIER function, the token is a single-quoted string literal
        // which has quoteType notQuoted but starts with single quote
        boolean isSnowflakeSingleQuotedString = (this.dbvendor == EDbVendor.dbvsnowflake)
                && token.toString().startsWith("'");

        if (getQuoteType() == EQuoteType.notQuoted && !isSnowflakeSingleQuotedString) return;
//        if ((this.dbvendor != EDbVendor.dbvbigquery)
//                &&(getQuoteType() == EQuoteType.doubleQuote)) return;

        String tokenStr = token.toString();
        char outerQuoteChar = tokenStr.charAt(0);
        String s = TBaseType.getTextWithoutQuoted(tokenStr);
        String[] a = s.split("[.]");
        if (a.length == 1){
            // this.objectToken = token;
        }else if (a.length == 2){
            String objPart = a[1];
            String schemaPart = a[0];

            // For Snowflake IDENTIFIER function with single-quoted string containing double-quoted parts
            // e.g., IDENTIFIER('"SCHEMA"."TABLE"') -> parts already have double quotes
            // For unquoted parts, e.g., IDENTIFIER('schema.table') -> use parts as-is
            boolean isSnowflakeIdentifierFunction = (this.dbvendor == EDbVendor.dbvsnowflake) && (outerQuoteChar == '\'');

            if (isSnowflakeIdentifierFunction) {
                this.objectToken = new TSourceToken(objPart);
                this.schemaToken = new TSourceToken(schemaPart);
            } else {
                this.objectToken = new TSourceToken(outerQuoteChar + objPart + outerQuoteChar);
                this.schemaToken = new TSourceToken(outerQuoteChar + schemaPart + outerQuoteChar);
            }
        }else if (a.length == 3){
            String objPart = a[2];
            String schemaPart = a[1];
            String dbPart = a[0];

            boolean isSnowflakeIdentifierFunction = (this.dbvendor == EDbVendor.dbvsnowflake) && (outerQuoteChar == '\'');

            if (isSnowflakeIdentifierFunction) {
                this.objectToken = new TSourceToken(objPart);
                this.schemaToken = new TSourceToken(schemaPart);
                this.databaseToken = new TSourceToken(dbPart);
            } else {
                this.objectToken = new TSourceToken(outerQuoteChar + objPart + outerQuoteChar);
                this.schemaToken = new TSourceToken(outerQuoteChar + schemaPart + outerQuoteChar);
                this.databaseToken = new TSourceToken(outerQuoteChar + dbPart + outerQuoteChar);
            }
        }

    }

    private TObjectName(EDbVendor dbVendor){
        this.dbvendor = dbVendor;
    }

    private TObjectName(EDbVendor dbVendor,EDbObjectType dbObjectType){
        this.dbvendor = dbVendor;
        this.dbObjectType = dbObjectType;
    }

    private TObjectName(EDbVendor dbVendor, EDbObjectType dbObjectType,TSourceToken token){
        this.dbvendor = dbVendor;
        numberOfPart = 1;
        this.setStartToken(token);
        this.setEndToken(token);

        this.dbObjectType = dbObjectType;
        switch (dbObjectType){
            case column:
                this.partToken = token;
                break;
            case method:
                this.methodToken = token;
                break;
            case table:
            case function:
            case procedure:
            case materializedView:
            case alias:
            case module:
            case sequence:
            case collation:
                this.objectToken = token;
                splitNameInQuotedIdentifier();
                break;
            default:
                this.objectToken = token;
                break;
        }
    }

    private void initWithOneToken(EDbObjectType dbObjectType,TSourceToken token){
        numberOfPart = 1;
        this.setStartToken(token);
        this.setEndToken(token);

        this.dbObjectType = dbObjectType;
        switch (dbObjectType){
            case column:
                this.partToken = token;
                break;
            case method:
                this.methodToken = token;
                break;
            case table:
            case function:
            case procedure:
            case materializedView:
            case alias:
            case module:
            case sequence:
            case collation:
            case stage:
                this.objectToken = token;
                splitNameInQuotedIdentifier();
                break;
            case namespace:
                this.schemaToken = token;
                break;
            default:
                this.objectToken = token;
                break;
        }
    }

    private void initWithTwoTokens(EDbObjectType dbObjectType,TSourceToken token2,TSourceToken token1){
        initWithOneToken(dbObjectType,token1);
        numberOfPart = 2;
        this.setStartToken(token2);
        this.setEndToken(token1);

        switch (dbObjectType){
            case column:
                this.objectToken = token2;
                break;
            case method:
                this.partToken = token2;
                break;
            case table:
            case function:
            case procedure:
            case materializedView:
            case alias:
            case module:
            case sequence:
            case collation:
            case stage:
                this.schemaToken = token2;
                break;
            case namespace:
                this.databaseToken = token2;
                break;
            default:
                this.schemaToken = token2;
                break;
        }

    }

    private void initWithThreeTokens(EDbObjectType dbObjectType,TSourceToken token3,TSourceToken token2,TSourceToken token1){
        initWithTwoTokens(dbObjectType,token2,token1);
        numberOfPart = 3;
        this.setStartToken(token3);
        this.setEndToken(token1);

        switch (dbObjectType){
            case column:
                this.schemaToken = token3;
                break;
            case method:
                this.objectToken = token3;
                break;
            case table:
            case function:
            case procedure:
            case materializedView:
            case alias:
            case module:
            case sequence:
            case collation:
            case stage:
                this.databaseToken = token3;
                break;
            default:
                this.databaseToken = token3;
                break;
        }

    }

    private void initWithFourTokens(EDbObjectType dbObjectType,TSourceToken token4,TSourceToken token3,TSourceToken token2,TSourceToken token1){
        initWithThreeTokens(dbObjectType,token3,token2,token1);
        numberOfPart = 4;
        this.setStartToken(token4);
        this.setEndToken(token1);

        switch (dbObjectType){
            case column:
                this.databaseToken = token4;
                break;
            case method:
                this.schemaToken = token4;
                break;
            case table:
            case function:
            case procedure:
            case materializedView:
            case alias:
            case module:
            case sequence:
            case collation:
                this.serverToken = token4;
                break;
            default:
                this.serverToken = token4;
                break;
        }

    }

    /**
     * @deprecated As of v2.0.7.1, please use {@link TObjectName#createObjectName(EDbVendor, EDbObjectType, TSourceToken)} instead.
     * 
     * @param dbObjectType
     * @param token
     */
    private TObjectName(EDbObjectType dbObjectType,TSourceToken token){
        initWithOneToken(dbObjectType,token);
    }

    private TObjectName(EDbVendor dbVendor, EDbObjectType dbObjectType,TSourceToken token2,TSourceToken token1){
        this(dbVendor,dbObjectType,token1);
        numberOfPart = 2;
        this.setStartToken(token2);
        this.setEndToken(token1);

        switch (dbObjectType){
            case column:
                this.objectToken = token2;
                break;
            case method:
                this.partToken = token2;
                break;
            case table:
            case function:
            case procedure:
            case materializedView:
            case alias:
            case module:
            case sequence:
            case collation:
                if (dbVendor == EDbVendor.dbvteradata){
                    this.databaseToken = token2;
                }else{
                    this.schemaToken = token2;
                }

                break;
            default:
                this.schemaToken = token2;
                break;
        }

    }


    /**
     * @deprecated since ver 2.5.9.8
     *
     * @param dbObjectType
     * @param token2
     * @param token1
     */
    private TObjectName(EDbObjectType dbObjectType,TSourceToken token2,TSourceToken token1){
        this(dbObjectType,token1);
        numberOfPart = 2;
        this.setStartToken(token2);
        this.setEndToken(token1);

        switch (dbObjectType){
            case column:
                this.objectToken = token2;
                break;
            case method:
                this.partToken = token2;
                break;
            case table:
            case function:
            case procedure:
            case materializedView:
            case alias:
            case module:
            case sequence:
            case collation:
                this.schemaToken = token2;
                break;
            default:
                this.schemaToken = token2;
                break;
        }
    }
    private TObjectName(EDbVendor dbVendor, EDbObjectType dbObjectType,TSourceToken token3,TSourceToken token2,TSourceToken token1){
        this(dbVendor,dbObjectType,token2,token1);
        numberOfPart = 3;
        this.setStartToken(token3);
        this.setEndToken(token1);

        switch (dbObjectType){
            case column:
                this.schemaToken = token3;
                break;
            case method:
                this.objectToken = token3;
                break;
            case table:
            case function:
            case procedure:
            case materializedView:
            case alias:
            case module:
            case sequence:
            case collation:
                this.databaseToken = token3;
                break;
            default:
                this.databaseToken = token3;
                break;
        }

    }


    /**
     * @deprecated since ver 2.5.9.8
     *
     * @param dbObjectType
     * @param token3
     * @param token2
     * @param token1
     */
    private TObjectName(EDbObjectType dbObjectType,TSourceToken token3,TSourceToken token2,TSourceToken token1){
        this(dbObjectType,token2,token1);
        numberOfPart = 3;
        this.setStartToken(token3);
        this.setEndToken(token1);

        switch (dbObjectType){
            case column:
                this.schemaToken = token3;
                break;
            case method:
                this.objectToken = token3;
                break;
            case table:
            case function:
            case procedure:
            case materializedView:
            case alias:
            case module:
            case sequence:
            case collation:
                this.databaseToken = token3;
                break;
            default:
                this.databaseToken = token3;
                break;
        }
    }

    private TObjectName(EDbVendor dbVendor, EDbObjectType dbObjectType,TSourceToken token4,TSourceToken token3,TSourceToken token2,TSourceToken token1){
        this(dbVendor,dbObjectType,token3,token2,token1);
        numberOfPart = 4;
        this.setStartToken(token4);
        this.setEndToken(token1);

        switch (dbObjectType){
            case column:
                this.databaseToken = token4;
                break;
            case method:
                this.schemaToken = token4;
                break;
            case table:
            case function:
            case procedure:
            case materializedView:
            case alias:
            case module:
            case sequence:
            case collation:
                this.serverToken = token4;
                break;
            default:
                this.serverToken = token4;
                break;
        }

    }

    /**
     * @deprecated since ver 2.5.9.8
     *
     * @param dbObjectType
     * @param token4
     * @param token3
     * @param token2
     * @param token1
     */
    private TObjectName(EDbObjectType dbObjectType,TSourceToken token4,TSourceToken token3,TSourceToken token2,TSourceToken token1){
        this(dbObjectType,token3,token2,token1);
        numberOfPart = 4;
        this.setStartToken(token4);
        this.setEndToken(token1);

        switch (dbObjectType){
            case column:
                this.databaseToken = token4;
                break;
            case method:
                this.schemaToken = token4;
                break;
            case table:
            case function:
            case procedure:
            case materializedView:
            case alias:
            case module:
            case sequence:
            case collation:
                this.serverToken = token4;
                break;
            default:
                this.serverToken = token4;
                break;
        }
    }

    /**
     * @deprecated As of v2.0.7.1, please use {@link #TObjectName(EDbObjectType, TSourceToken, TSourceToken)} instead.
     *
     * Class constructor specifying object, part name and object type.
     * Use this constructor to create a <code>table.column</code> objectName.
     * Use {@link gudusoft.gsqlparser.TGSqlParser#parseObjectName} to create an objectName more than 2 parts.
     *
     * @param pObjectToken    name of this object, usually it's the table name
     * @param pPartToken      name of the column
     * @param dbObjectType    type of this object, usually it's {@link gudusoft.gsqlparser.EDbObjectType#column}
     */
    private TObjectName(TSourceToken pObjectToken,TSourceToken pPartToken,EDbObjectType dbObjectType){
        this(dbObjectType,pObjectToken,pPartToken);
    }

    public void init(Object arg1)
    {
        partToken = (TSourceToken)arg1;
        numberOfPart = 1;
        this.setStartToken(partToken);
        this.setEndToken(partToken);
    }

    public void init(Object arg1, Object arg2)
    {
        if (arg1 instanceof EDbObjectType){
            initWithOneToken((EDbObjectType)arg1,(TSourceToken) arg2);

        }else{
            numberOfPart = 0;
            objectToken = (TSourceToken)arg1;
            partToken = (TSourceToken)arg2;
            if (partToken != null) numberOfPart++;
            if (objectToken != null) numberOfPart++;


            if(objectToken != null){
                this.setStartToken(objectToken);
            }else{
                this.setStartToken(partToken);
            }

            if (partToken != null){
                this.setEndToken(partToken);
            }else{
                this.setEndToken(objectToken);
            }
        }
    }

    public void init(EDbObjectType dbObjectType, Object arg1, Object arg2, Object arg3){
        numberOfPart = 0;
        if (arg1 != null) numberOfPart++;
        if (arg2 != null) numberOfPart++;
        if (arg3 != null) numberOfPart++;

        this.dbObjectType = dbObjectType;
        this.setStartToken((TSourceToken)arg1);
        this.setEndToken((TSourceToken)arg3);
        switch (this.dbObjectType){
            case column:
                schemaToken = (TSourceToken)arg1;
                objectToken = (TSourceToken)arg2;
                partToken = (TSourceToken)arg3;
                break;
            case table:
            case function:
            case procedure:
            case materializedView:
            case module:
            case sequence:
                databaseToken = (TSourceToken) arg1;
                schemaToken = (TSourceToken)arg2;
                objectToken = (TSourceToken)arg3;
                break;
            case alias:
                break;
            default:
                break;
        }

    }

    public void init(Object arg1, Object arg2, Object arg3)
    {
        if (arg1 instanceof EDbObjectType){
            initWithTwoTokens((EDbObjectType)arg1,(TSourceToken) arg2,(TSourceToken) arg3);
        }else{
            numberOfPart = 0;
            if (arg1 != null) numberOfPart++;
            if (arg2 != null) numberOfPart++;
            if (arg3 != null) numberOfPart++;

            if (dbvendor == EDbVendor.dbvteradata){
                databaseToken = (TSourceToken) arg1;
                this.setStartToken(databaseToken);
            }else{
                schemaToken = (TSourceToken)arg1;
                this.setStartToken(schemaToken);
                if (schemaToken != null)
                   {schemaToken.setDbObjType(TObjectName.ttobjSchemaName);}
            }

            objectToken = (TSourceToken)arg2;
            partToken = (TSourceToken)arg3;
            this.setEndToken(partToken);
        }
    }

    public void init(Object arg1, Object arg2, Object arg3, Object arg4)
    {
        if (arg1 instanceof EDbObjectType){
            //this.dbObjectType = (EDbObjectType)arg1;
            //init(arg2,arg3,arg4);
            initWithThreeTokens((EDbObjectType)arg1,(TSourceToken)arg2,(TSourceToken)arg3,(TSourceToken)arg4);
        }else{
            numberOfPart = 0;
            if (arg1 != null) numberOfPart++;
            if (arg2 != null) numberOfPart++;
            if (arg3 != null) numberOfPart++;
            if (arg4 != null) numberOfPart++;

            //serverToken = (TSourceToken)arg1;
            databaseToken = (TSourceToken)arg1;
            schemaToken = (TSourceToken)arg2;
            objectToken = (TSourceToken)arg3;
            partToken = (TSourceToken)arg4;
            this.setStartToken(databaseToken);
            this.setEndToken(partToken);
            if (databaseToken != null){
                //databaseToken.setDbObjType(TObjectName.ttobjDatabaseName);
                databaseToken.setDbObjectType(EDbObjectType.database);
            }else {
            }
            if (schemaToken != null){
                schemaToken.setDbObjType(TObjectName.ttobjSchemaName);
            }else {
            }
        }
    }

    public void init(Object arg1, Object arg2, Object arg3, Object arg4, Object arg5)
    {
        numberOfPart = 0;
        if (arg1 != null) numberOfPart++;
        if (arg2 != null) numberOfPart++;
        if (arg3 != null) numberOfPart++;
        if (arg4 != null) numberOfPart++;
        if (arg5 != null) numberOfPart++;

        serverToken = (TSourceToken)arg1;
        databaseToken = (TSourceToken)arg2;
        schemaToken = (TSourceToken)arg3;
        objectToken = (TSourceToken)arg4;
        partToken = (TSourceToken)arg5;

        this.setStartToken(serverToken);
        this.setEndToken(partToken);

        if (serverToken != null){
            //serverToken.setDbObjType(TObjectName.ttobjServerName);
            serverToken.setDbObjectType(EDbObjectType.server);
        }else{
        }
        if (databaseToken != null){
            //databaseToken.setDbObjType(TObjectName.ttobjDatabaseName);
            databaseToken.setDbObjectType(EDbObjectType.database);
        }else{
        }
        if (schemaToken != null){
            schemaToken.setDbObjType(TObjectName.ttobjSchemaName);
        }else{
        }
    }

    public void init(Object arg1, Object arg2, Object arg3, Object arg4, Object arg5, Object arg6)
    {
        numberOfPart = 0;
        if (arg1 != null) numberOfPart++;
        if (arg2 != null) numberOfPart++;
        if (arg3 != null) numberOfPart++;
        if (arg4 != null) numberOfPart++;
        if (arg5 != null) numberOfPart++;
        if (arg6 != null) numberOfPart++;

        serverToken = (TSourceToken)arg1;
        databaseToken = (TSourceToken)arg2;
        schemaToken = (TSourceToken)arg3;
        objectToken = (TSourceToken)arg4;
        partToken = (TSourceToken)arg5;
        propertyToken = (TSourceToken)arg6;

        this.setStartToken(serverToken);
        this.setEndToken(propertyToken);

        if (serverToken != null){
            //serverToken.setDbObjType(TObjectName.ttobjServerName);
            serverToken.setDbObjectType(EDbObjectType.server);
        }else{
        }
        if (databaseToken != null){
           // databaseToken.setDbObjType(TObjectName.ttobjDatabaseName);
            databaseToken.setDbObjectType(EDbObjectType.database);
        }else{
        }
        if (schemaToken != null){
            schemaToken.setDbObjType(TObjectName.ttobjSchemaName);
        }else{
        }
    }

    /**
     * Init with 7 tokens for deeply nested struct field access (e.g., BigQuery)
     * Pattern: a.b.c.d.e.f.g (7 parts)
     */
    public void init(Object arg1, Object arg2, Object arg3, Object arg4, Object arg5, Object arg6, Object arg7)
    {
        // First 6 parts use standard tokens
        init(arg1, arg2, arg3, arg4, arg5, arg6);

        // 7th part goes to additionalParts
        if (arg7 != null) {
            if (additionalParts == null) {
                additionalParts = new java.util.ArrayList<>();
            }
            additionalParts.add((TSourceToken) arg7);
            numberOfPart++;
            this.setEndToken((TSourceToken) arg7);
        }
    }

    /**
     * Init with 8 tokens for deeply nested struct field access
     * Pattern: a.b.c.d.e.f.g.h (8 parts)
     */
    public void init(Object arg1, Object arg2, Object arg3, Object arg4, Object arg5, Object arg6, Object arg7, Object arg8)
    {
        init(arg1, arg2, arg3, arg4, arg5, arg6, arg7);

        if (arg8 != null) {
            if (additionalParts == null) {
                additionalParts = new java.util.ArrayList<>();
            }
            additionalParts.add((TSourceToken) arg8);
            numberOfPart++;
            this.setEndToken((TSourceToken) arg8);
        }
    }

    /**
     * Init with 9 tokens for deeply nested struct field access
     * Pattern: a.b.c.d.e.f.g.h.i (9 parts)
     */
    public void init(Object arg1, Object arg2, Object arg3, Object arg4, Object arg5, Object arg6, Object arg7, Object arg8, Object arg9)
    {
        init(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);

        if (arg9 != null) {
            if (additionalParts == null) {
                additionalParts = new java.util.ArrayList<>();
            }
            additionalParts.add((TSourceToken) arg9);
            numberOfPart++;
            this.setEndToken((TSourceToken) arg9);
        }
    }

    /**
     * Init with 10 tokens for deeply nested struct field access
     * Pattern: a.b.c.d.e.f.g.h.i.j (10 parts)
     */
    public void init(Object arg1, Object arg2, Object arg3, Object arg4, Object arg5, Object arg6, Object arg7, Object arg8, Object arg9, Object arg10)
    {
        init(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);

        if (arg10 != null) {
            if (additionalParts == null) {
                additionalParts = new java.util.ArrayList<>();
            }
            additionalParts.add((TSourceToken) arg10);
            numberOfPart++;
            this.setEndToken((TSourceToken) arg10);
        }
    }

    /**
     * Get additional parts beyond the standard 6 tokens.
     * Used for deeply nested struct field access in databases like BigQuery.
     *
     * @return list of additional source tokens, or null if none
     */
    public java.util.List<TSourceToken> getAdditionalParts() {
        return additionalParts;
    }

    /**
     * The column position of this objectName in the SQL
     *
     * @return column position
     */
    @Override
    public long getColumnNo() {
        long retval = -1;
        if (partToken != null) { retval = partToken.columnNo;}
        if (objectToken != null) {
              retval = objectToken.columnNo;
        }
        if (schemaToken != null) {
              retval = schemaToken.columnNo;
        }
        if (databaseToken != null) {
              retval = databaseToken.columnNo;
        }
        if (serverToken != null) {
              retval = serverToken.columnNo;
        }
        return retval;
    }

    /**
     * The line number of this objectName in SQL
     *
     * @return the line number
     */
    @Override
    public long getLineNo() {
        long retval = -1;
        if (partToken != null) { retval = partToken.lineNo;}
        if (objectToken != null) {
              retval = objectToken.lineNo;
        }
        if (schemaToken != null) {
              retval = schemaToken.lineNo;
        }
        if (databaseToken != null) {
              retval = databaseToken.lineNo;
        }
        if (serverToken != null) {
              retval = serverToken.lineNo;
        }
        return retval;
    }

   private TObjectNameList referencedObjects = null;

    public TObjectNameList getReferencedObjects() {
        if (referencedObjects == null){
            referencedObjects = new TObjectNameList();
        }
        return referencedObjects;
    }

    /**
     * Returns only the column name if it's prefixed with a table name
     *
     * @return only the column name if it's prefixed with a table name
     */
    public String getColumnNameOnly(){

        if (getPartToken() == null) return "";
        else  return getPartToken().toString();
    }

    public void accept(TParseTreeVisitor v){
        v.preVisit(this);
        v.postVisit(this);
    }

    public void acceptChildren(TParseTreeVisitor v){
        v.preVisit(this);
        v.postVisit(this);
    }

//    private TSourceToken sortType = null;
//
//    public void setSortType(TSourceToken sortType) {
//        this.sortType = sortType;
//    }
//
//    /**
//     * When this object is column in primary key(column,...), unique key(column,...) in sql server
//     * there maybe sort information like column asc, column desc
//     * this token represents for ASC, DESC if specified.
//     *
//     * @return ASC, DESC or null
//     */
//
//    public TSourceToken getSortType() {
//        return sortType;
//    }

    /**
     * It's the same as {@link #getPartToken} if {@link #getDbObjectType} is {@link gudusoft.gsqlparser.EDbObjectType#column}
     *
     * @return source token that represents column, return null if this objectName is not type of column
     *
     */
    public TSourceToken getColumnToken(){
        TSourceToken ret = null;
        if (this.getObjectType() == ttobjColumn){
            ret = this.getPartToken();
        }
        return ret;
    }

    /*
     *  re-arranage objectname to make it a valid name includes attribute name
      * used by teradata yacc file only.
      * valid syntax:
       * column.attr1().attr2().
       * column.attr1().attr2().attr3()
       * table.column.attr1().attr2().
       * table.column.attr1().attr2().attr3()
       *
     *   @return
     */
   public boolean isAttributeNameInObjectName(TSourceToken leftparen,TSourceToken rightparen){
        boolean ret = false;
        if ((this.partToken == null) || (this.objectToken == null)){
            return ret;
        }
        this.objectType = TObjectName.ttobjColumn;
        this.columnAttributes = new TObjectNameList();
        TObjectName attr1 = new TObjectName();
        attr1.objectType = TObjectName.ttobjAttribute;
        attr1.init(this.partToken);
        attr1.setEndToken(rightparen);
        this.columnAttributes.addObjectName(attr1);

        this.partToken = this.objectToken;

        if (this.schemaToken != null){
            this.objectToken = this.schemaToken;
        }

        return true;
   }

    /**
     * Used internally in hive .y file to merge two objectNames
     */
    public void mergeObjectName(TObjectName objectName){
        this.objectToken = this.partToken;
        this.partToken = objectName.getPartToken();
        this.setStartToken(objectToken);
        this.setEndToken(partToken);
    }

    public void mergeObjectName(TObjectName objectName,TObjectName objectName2){
        this.schemaToken = this.partToken;
        this.objectToken = objectName.getPartToken();
        this.partToken = objectName2.getPartToken();
        this.setStartToken(schemaToken);
        this.setEndToken(partToken);
    }


    public void columnToProperty(){
        // if (numberOfPart == 1) return;
        if (this.pseudoTableType != EPseudoTableType.none) return; // pseudo table tokens already in correct position
        if (this.propertyToken != null) return; // columnToProperty() already called
        if (! ((this.partToken != null) && (this.objectToken != null))) return; // 既然是 column.property ， 那么 partToken and objectToken 不能为空

        this.propertyToken = this.partToken;
        this.partToken = this.objectToken;
        this.objectToken = this.schemaToken;
        // Shift the whole qualifier chain, not just the three rightmost slots.
        // Stopping at objectToken left schemaToken holding a copy of the value
        // that just moved into objectToken, so re-assembling
        // schema.object.part for "alias.column.attribute" produced
        // "alias.alias.column" instead of "alias.column" (Mantis #4675).
        this.schemaToken = this.databaseToken;
        this.databaseToken = this.serverToken;
        this.serverToken = null;

        this.setDbObjectTypeDirectly(EDbObjectType.column);
    }

    /**
     * The identifiers this name is written with, in order, up to its first subscript.
     * <p>
     * {@code payload.items[1].name} gives {@code payload, items}, and {@code e.payload.address.city} gives all four
     * parts. A name of five or more parts gives all of them too, although the grammar keeps only its first part in
     * the name slots and the rest in {@link #getIndirection()}. The parse decides what an identifier is: a subscript,
     * a {@code :} path, a bind variable or a method call ends the chain, and a name with a wildcard part has no chain.
     *
     * @return the identifier tokens, empty when this name has none
     */
    public java.util.List<TSourceToken> getIdentifierChain() {
        java.util.List<TSourceToken> chain = identifierTokens();
        for (TSourceToken part : chain) {
            if (part.tokentype == ETokenType.ttasterisk) {
                chain.clear();
                break;
            }
        }
        return chain;
    }

    /**
     * The identifiers before the wildcard of a name that ends with one, as written: {@code e.payload.*} gives
     * {@code e, payload}, BigQuery {@code customer.address.*} gives {@code customer, address}. The wildcard comes from
     * the parse, the asterisk token, never from the text. Empty for any other name.
     *
     * @return the identifier tokens before the wildcard
     */
    public java.util.List<TSourceToken> getStarQualifierChain() {
        java.util.List<TSourceToken> tokens = identifierTokens();
        java.util.List<TSourceToken> chain = new ArrayList<TSourceToken>();
        if (tokens.size() < 2 || tokens.get(tokens.size() - 1).tokentype != ETokenType.ttasterisk) {
            return chain;
        }
        for (int i = 0; i < tokens.size() - 1; i++) {
            if (tokens.get(i).tokentype == ETokenType.ttasterisk) {
                chain.clear();
                return chain;
            }
            chain.add(tokens.get(i));
        }
        return chain;
    }

    /** The identifiers of {@link #getIdentifierChain()}, a wildcard part included. */
    private java.util.List<TSourceToken> identifierTokens() {
        java.util.List<TSourceToken> chain = new ArrayList<TSourceToken>();
        TSourceToken[] slots = {serverToken, databaseToken, schemaToken, objectToken, partToken, propertyToken};
        if (indirection == null || indirection.getIndices() == null || indirection.getIndices().size() == 0) {
            for (TSourceToken slot : slots) {
                if (slot != null) chain.add(slot);
            }
            // parts beyond the six slots (BigQuery a.b.c.d.e.f.g)
            if (additionalParts != null) {
                chain.addAll(additionalParts);
            }
        } else {
            // The indirection holds every part after the first one, including those the grammar copied into the
            // name slots (TObjectName.setIndirection), so the chain is the first part followed by the indirection.
            for (TSourceToken slot : slots) {
                if (slot != null) {
                    chain.add(slot);
                    break;
                }
            }
            for (int i = 0; i < indirection.getIndices().size() && !chain.isEmpty(); i++) {
                TIndices index = indirection.getIndices().getElement(i);
                TSourceToken start = index.getStartToken();
                if (index.getIndicesType() != TIndices.IndicesType.QUALIFIED_NAME || index.getAttributeName() == null
                        || index.getAttributeName().getPartToken() == null
                        || (start != null && (start.tokencode == ':' || start.tokencode == '['
                                || start.tokencode == TBaseType.bind_v))) {
                    break;
                }
                chain.add(index.getAttributeName().getPartToken());
            }
            // The slots must still read this chain from its start, as setIndirection left them; a name whose slots
            // were rewritten some other way keeps the slots as its chain.
            int at = 0;
            for (TSourceToken slot : slots) {
                if (slot == null) continue;
                while (at < chain.size() && chain.get(at) != slot) at++;
                if (at == chain.size()) {
                    chain.clear();
                    for (TSourceToken s : slots) {
                        if (s != null) chain.add(s);
                    }
                    if (additionalParts != null) {
                        chain.addAll(additionalParts);
                    }
                    break;
                }
            }
        }
        return chain;
    }

    /**
     * Re-read this column name as a column followed by {@code fieldCount} fields of its value, counted from the end of
     * {@link #getIdentifierChain()}: the part before the fields becomes the column token, the first field the
     * property token, and the parts before the column its qualifier.
     * <p>
     * This is {@link #columnToProperty()} for a field path of any length. In Athena {@code payload.address.city} the
     * grammar fills the slots as schema {@code payload}, table {@code address}, column {@code city}; with two fields it
     * becomes column {@code payload} with property {@code address}, and {@code e.payload.address.city} becomes table
     * {@code e}, column {@code payload}, property {@code address} (Mantis 4822). The fields stay readable from the
     * resolver's field path and from {@link #getIndirection()}. Calling it again with the same count changes nothing.
     *
     * @param fieldCount how many trailing parts of the chain are fields, at least 1
     */
    public void columnToFieldPath(int fieldCount) {
        if (this.pseudoTableType != EPseudoTableType.none) return; // pseudo table tokens already in correct position
        java.util.List<TSourceToken> chain = getIdentifierChain();
        int column = chain.size() - 1 - fieldCount;
        if (fieldCount < 1 || column < 0) {
            // no chain to count the fields in: shift one part, as before
            columnToProperty();
            return;
        }
        if (this.partToken == chain.get(column) && this.propertyToken == chain.get(column + 1)) return;
        // more qualifiers than the slots before the column can hold: leave the name as the grammar read it
        if (column > 4) return;

        if (indirection == null && column + 2 < chain.size()) {
            // the slots end at the property: the fields after it stay parts of the name, so the chain still reads
            // customer.address.city after the move (Hive, Mantis 4837)
            java.util.List<TSourceToken> rest = new ArrayList<TSourceToken>(chain.subList(column + 2, chain.size()));
            this.additionalParts = rest;
        } else if (indirection == null) {
            this.additionalParts = null;
        }
        this.propertyToken = chain.get(column + 1);
        this.partToken = chain.get(column);
        this.objectToken = column >= 1 ? chain.get(column - 1) : null;
        this.schemaToken = column >= 2 ? chain.get(column - 2) : null;
        this.databaseToken = column >= 3 ? chain.get(column - 3) : null;
        this.serverToken = column >= 4 ? chain.get(column - 4) : null;
        this.normalizedServer = null;
        this.normalizedDatabase = null;
        this.normalizedSchema = null;
        this.normalizedTable = null;
        this.normalizedColumn = null;

        this.setDbObjectTypeDirectly(EDbObjectType.column);
    }

    /**
     * The STRUCT field path this column reference reads below its column, as written: the column it reads into,
     * then each field and array element after it. BigQuery {@code customer.address.city} reads
     * {@code customer.address.city}; Athena {@code payload.items[1].name} reads {@code payload.items[*].name}, a
     * subscript being the array element segment of {@link gudusoft.gsqlparser.common.structured.StructuredColumnPath}.
     * <p>
     * This is the one place that answers which column a reference reads and which field below it. The evidence is
     * what TSQLResolver2 proved: a struct-field reading of the name ({@link #getColumnSource()} with a field path), or
     * BigQuery's reading of a name of three or more parts without an alias ({@link #getStructFieldHint()}). In the
     * Trino family the parse adds the parts after those fields and after a subscript, which the resolver does not
     * read: an array element and its fields ({@code items[1].name} reads {@code items[*].name}).
     *
     * @return the path read, rooted at the column's name as written; null when the reference reads a whole column
     */
    public gudusoft.gsqlparser.common.structured.StructuredColumnPath getFieldPathRead() {
        gudusoft.gsqlparser.nodes.structured.NestedAccess access = getNestedAccess();
        return access == null ? null : access.getPath();
    }

    /**
     * The token of the column whose field {@link #getFieldPathRead()} reads, such as {@code customer} in
     * {@code o.customer.address.city}; null when the reference reads a whole column.
     */
    public TSourceToken getFieldPathBaseToken() {
        gudusoft.gsqlparser.nodes.structured.NestedAccess access = getNestedAccess();
        return access == null ? null : access.getBaseToken();
    }

    /**
     * The STRUCT column or field whose fields a wildcard below it reads, as written: BigQuery {@code customer.*} reads
     * every field of {@code customer}, {@code customer.address.*} every field of {@code customer.address}, and
     * Athena {@code e.payload.*} every field of {@code payload}. The evidence is what TSQLResolver2 proved, as for
     * {@link #getFieldPathRead()}: a struct-field reading whose field path ends at the wildcard, BigQuery's reading of
     * a name of three or more parts without an alias, or, in the Trino family, the column the name was bound to with
     * the wildcard right after it.
     *
     * @return the column or field path the wildcard expands, rooted at the column's name as written; null when the
     *         name is not a wildcard below a column
     */
    public gudusoft.gsqlparser.common.structured.StructuredColumnPath getStructStarPath() {
        gudusoft.gsqlparser.nodes.structured.NestedAccess access = getNestedStarAccess();
        return access == null ? null
                : gudusoft.gsqlparser.nodes.structured.NestedAccessNormalizer.withoutStar(access.getPath());
    }

    /** The token of the column {@link #getStructStarPath()} starts at; null when that is null. */
    public TSourceToken getStructStarBaseToken() {
        gudusoft.gsqlparser.nodes.structured.NestedAccess access = getNestedStarAccess();
        return access == null ? null : access.getBaseToken();
    }

    public void appendObjectName(TObjectName objectName){
        if (this.databaseToken != null){
            this.serverToken = this.databaseToken;
        }
        if (this.schemaToken != null){
            this.databaseToken = this.schemaToken;
        }
        if (this.objectToken != null){
            this.schemaToken = this.objectToken;
        }
        this.objectToken = this.partToken;
        this.partToken = objectName.getPartToken();
        this.setEndTokenDirectly(this.partToken);
    }

    private TSourceToken commentString;

    public void setCommentString(TSourceToken commentString) {
        this.commentString = commentString;
    }

    public TSourceToken getCommentString() {

        return commentString;
    }


    /**
     * The X and Y position of this objectName in the SQL
     *
     * @return coordinate in string text
     */
    public String coordinate(){
        return this.getStartToken().lineNo+","+this.getEndToken().columnNo;
    }


    /**
     * @deprecated replaced by {@link EDbObjectType}.
     *
     * this is not an object, like sysdate function in oracle database
     */
    public final static int ttobjNotAObject = -1;

    /**
     * @deprecated replaced by {@link EDbObjectType}.
     * object type can't be determined.
     */
    public final static int ttobjUnknown = 0;

    /**
     * @deprecated replaced by {@link EDbObjectType}.
     * column in table, objectToken is table if specified, and partToken is column name.
     */
    public final static int ttobjColumn = 1;

    /**
     * @deprecated replaced by {@link EDbObjectType}.
     * column alias in objectToken.
     */
    public final static int ttobjColumnAlias = 2;

    /**
     * @deprecated replaced by {@link EDbObjectType}.
     * table name in objectToken.
     */
    public final static int ttobjTable = 3;


    /**
     * @deprecated replaced by {@link EDbObjectType}.
     * parameter name in objectToken.
     */
    public final static int ttobjParameter = 9;

    /**
     * @deprecated replaced by {@link EDbObjectType}.
     * variable name in objectToken.
     */
    public final static int ttobjVariable = 10;


    /**
     * @deprecated replaced by {@link EDbObjectType#method}.
     *  column method like SetXY below, column method in {@link #methodToken}, and colomn name in {@link #partToken}.
     *<p>   UPDATE Cities
     *<p>   SET Location.SetXY(23.5, 23.5)
     *
     *
     */
    public final static int ttobjColumnMethod = 11;

    /**
     * Named argument parameter name in function calls.
     * <p>Example: In Snowflake FLATTEN(INPUT => parse_json(col), outer => TRUE),
     * "INPUT" and "outer" are named argument parameter names, NOT column references.
     * <p>These should be skipped during column resolution and data lineage analysis.
     */
    public final static int ttobjNamedArgParameter = 12;

    /**
     * Lambda parameter, at its declaration and at every use in the lambda body.
     * <p>Example: in Trino/Athena {@code filter(arr, (x) -> x <> '')} or Databricks
     * {@code transform(arr, x -> x + 1)}, both occurrences of {@code x} are lambda parameters,
     * NOT column references. TSQLResolver2 sets this marker; data lineage skips such names so a
     * lambda parameter never becomes an orphan column (Mantis 4805).
     */
    public final static int ttobjLambdaParameter = 62;

    /**
     * @deprecated replaced by {@link EDbObjectType}.
     * function name in {@link #objectToken}
     */
    public final static int ttobjFunctionName = 13;


    /**
     * @deprecated replaced by {@link EDbObjectType#constraint}.
     * constraint name in {@link #objectToken}
     */
    public final static int ttobjConstraintName = 19;

    /**
     * @deprecated replaced by {@link EDbObjectType}.
     * string constant in {@link #objectToken}
     */
    public final static int ttobjStringConstant = 23;


    /**
     * @deprecated replaced by {@link EDbObjectType}.
     * attribute name is in {@link #partToken}
     */
    public final static int ttobjAttribute = 26;


    /**
     * @deprecated replaced by {@link EDbObjectType}.
     * datatype was not represented by a TObjectName object, this constant was used in source tokens that consist of  TTypeName.
     */
    public final static int ttobjDatatype = 30;

    /**
     * @deprecated replaced by {@link EDbObjectType}.
     *  schema name in {@link #schemaToken}
     */
    public final static int ttobjSchemaName = 31;


    /**
     * @deprecated replaced by {@link EDbObjectType}.
     * postgresql
     * Positional Parameters, $1, $1[1], $1[1,10]
     * parameter name is in {@link #partToken} of $1,
     * and parameter name is in {@link #objectToken} of $1.columnName,
     * and column name is in {@link #partToken}
     */

    public final static int ttobjPositionalParameters = 61;



    private void setColumnTokenOfPositionalParameters(TSourceToken column){
        this.objectToken = this.partToken;
        this.partToken = column;
    }

    private int objectType = ttobjUnknown;


    /**
     * @deprecated replaced by {@link EDbObjectType}.
     * this type is used in TObjectNameList, when objects in TObjectNameList includes more than
     * one type, objtype of that TObjectNameList was set to ttobjMixed.
     *
     * removed since v2.9.2.5
     */
   // public final static int ttobjMixed = 100;

    /**
     * @deprecated replaced by {@link EDbObjectType#library}.
     * removed since v2.9.2.5
     */
   // public final static  int ttObjLibrary = 72;

    /**
     * @deprecated replaced by {@link EDbObjectType#oracleHint}.
     * removed since v2.9.2.5
     */
   // public final static  int ttObjOracleHint = 70;

    /**
     * @deprecated replaced by {@link EDbObjectType#fieldName}.
     * check {@link gudusoft.gsqlparser.nodes.TExpression#getFieldName()} for more
     * removed since v2.9.2.5
     */
   // public final static int ttobjFieldName = 51;

    /**
     * @deprecated replaced by {@link EDbObjectType#miningModel}.
     * removed since v2.9.2.5
     */
    // public final static int ttobjMiningModel = 46;

    /**
     * @deprecated replaced by {@link EDbObjectType#materializedView}.
     * removed since v2.9.2.5
     */
    // public final static int ttobjMaterializedView = 44;

    /**
     * @deprecated replaced by {@link EDbObjectType#indextype}.
     * removed since v2.9.2.5
     */
   // public final static int ttobjIndexType = 42;

    /**
     * @deprecated replaced by {@link EDbObjectType#operator}.
     * removed since v2.9.2.5
     */
    // public final static int ttobjOperator = 40;

    /**
     * @deprecated replaced by {@link EDbObjectType#server}.
     * server name in {@link #serverToken}
     *
     * removed since v2.9.2.5
     */
  //  public final static int ttobjServerName = 32;

    /**
     * @deprecated replaced by {@link EDbObjectType#sequence}.
     * Sequence name in {@link #objectToken}
     *
     * removed since v2.9.2.5
     */
   // public final static int ttobjSequence = 29;

    /**
     * @deprecated replaced by {@link EDbObjectType#plsql_package}.
     * package name in {@link #objectToken}
     *
     * removed since v2.9.2.5
     */
   // public final static int ttobjPackage = 28;

    /**
     * @deprecated replaced by {@link EDbObjectType#alias}.
     * alias name in {@link #objectToken}
     *
     * removed since v2.9.2.5
     */
   // public final static int ttobjAliasName = 25;


    /**
     * @deprecated replaced by {@link EDbObjectType#trigger}.
     * Trigger name in {@link #objectToken}
     *
     * removed since v2.9.2.5
     */
   // public final static int ttobjTrigger = 24;

    /**
     * @deprecated replaced by {@link EDbObjectType#database}.
     * Database name in {@link #objectToken}
     *
     * removed since v2.9.2.5
     */
   // public final static int ttobjDatabaseName = 22;

    /**
     * @deprecated replaced by {@link EDbObjectType#transaction}.
     * Transaction name in {@link #objectToken}
     *
     * removed since v2.9.2.5
     */
    // public final static int ttobjTransactionName = 21;


    /**
     * @deprecated replaced by {@link EDbObjectType#user_defined_type}.
     * type name in {@link #objectToken}
     *
     * removed since v2.9.2.5
     */
   // public final static int ttobjTypeName = 27;

    /**
     * @deprecated replaced by {@link EDbObjectType#property}.
     * property name in {@link #propertyToken}
     *
     * removed since v2.9.2.5
     */
   // public final static int ttobjPropertyName = 20;

    /**
     * @deprecated replaced by {@link EDbObjectType#view}.
     * view name in {@link #objectToken}
     *
     * removed since v2.9.2.5
     */
   // public final static int ttobjViewName = 18;

    /**
     * @deprecated replaced by {@link EDbObjectType#cursor}.
     * cursor name in {@link #objectToken}
     *
     * removed since v2.9.2.5
     */
  //  public final static int ttobjCursorName = 17;

    /**
     * @deprecated replaced by {@link EDbObjectType#materializedView}.
     * materialized view name in {@link #objectToken}
     *
     * removed since v2.9.2.5
     */
   // public final static int ttobjMaterializedViewName = 16;

    /**
     * @deprecated replaced by {@link EDbObjectType#index}.
     * index name in {@link #objectToken}
     *
     * removed since v2.9.2.5
     */
   // public final static int ttobjIndexName = 15;

    /**
     * @deprecated replaced by {@link EDbObjectType#label}.
     * label name in {@link #objectToken}
     *
     * removed since v2.9.2.5
     */
   // public final static int ttobjLabelName = 14;

    /**
     * @deprecated replaced by {@link EDbObjectType#procedure}.
     * procedure name in {@link #objectToken}
     *
     * removed since v2.9.2.5
     */
   // public final static int ttobjProcedureName = 12;

    /**
     * @deprecated replaced by {@link EDbObjectType#variable}.
     * table variable in objectToken.
     *
     * removed since v2.9.2.5
     */
   // public final static int ttobjTableVar = 8;

    /**
     * @deprecated replaced by {@link EDbObjectType#cte}.
     * table name in objectToken.
     *
     * removed since v2.9.2.5
     */
    // public final static int ttobjTableCTE = 5;

    /**
     * @deprecated replaced by {@link EDbObjectType}.
     * table name in objectToken.
     */
    // public final static int ttobjTableTemp = 6;

    /**
     * @deprecated replaced by {@link EDbObjectType}.
     */
    //  public final static int ttobjTablePivot = 7;

    /**
     * @deprecated replaced by {@link EDbObjectType#table_alias}.
     * table alias in objectToken
     *
     * removed since v2.9.2.5
     */
   // public final static int ttObjTableAlias = 4;
}