package gudusoft.gsqlparser.dlineage.dataflow.model;

import gudusoft.gsqlparser.dlineage.symbol.IdentityScope;
import gudusoft.gsqlparser.dlineage.symbol.LocalScopes;
import gudusoft.gsqlparser.dlineage.symbol.LocalSymbolKey;
import gudusoft.gsqlparser.dlineage.symbol.LocalSymbolNames;
import gudusoft.gsqlparser.dlineage.routine.RoutineAliasKey;
import gudusoft.gsqlparser.dlineage.routine.RoutineAliases;
import gudusoft.gsqlparser.EDbObjectType;
import gudusoft.gsqlparser.EDbVendor;
import gudusoft.gsqlparser.TSourceToken;
import gudusoft.gsqlparser.resolver2.metadata.StatementMetadata.ProcedureEnvironment;
import gudusoft.gsqlparser.ESqlStatementType;
import gudusoft.gsqlparser.ETableSource;
import gudusoft.gsqlparser.ETableEffectType;
import gudusoft.gsqlparser.TCustomSqlStatement;
import gudusoft.gsqlparser.dlineage.util.DlineageUtil;
import gudusoft.gsqlparser.dlineage.util.Pair;
import gudusoft.gsqlparser.dlineage.dynamicsql.RoutineIdentity;
import gudusoft.gsqlparser.dlineage.dynamicsql.RoutineKind;
import gudusoft.gsqlparser.nodes.TAliasClause;
import gudusoft.gsqlparser.nodes.TCaseExpression;
import gudusoft.gsqlparser.nodes.TConstant;
import gudusoft.gsqlparser.nodes.TDeclareVariable;
import gudusoft.gsqlparser.nodes.TExpression;
import gudusoft.gsqlparser.nodes.TFunctionCall;
import gudusoft.gsqlparser.nodes.TObjectName;
import gudusoft.gsqlparser.nodes.TObjectNameList;
import gudusoft.gsqlparser.nodes.TParameterDeclaration;
import gudusoft.gsqlparser.nodes.TParseTreeNode;
import gudusoft.gsqlparser.nodes.TPivotClause;
import gudusoft.gsqlparser.nodes.TResultColumn;
import gudusoft.gsqlparser.nodes.TTable;
import gudusoft.gsqlparser.nodes.TWhenClauseItemList;
import gudusoft.gsqlparser.sqlenv.ESQLDataObjectType;
import gudusoft.gsqlparser.sqlenv.TSQLColumn;
import gudusoft.gsqlparser.sqlenv.TSQLEnv;
import gudusoft.gsqlparser.sqlenv.TSQLTable;
import gudusoft.gsqlparser.stmt.TCreateTableSqlStatement;
import gudusoft.gsqlparser.stmt.TCreateViewSqlStatement;
import gudusoft.gsqlparser.stmt.TCursorDeclStmt;
import gudusoft.gsqlparser.stmt.TForStmt;
import gudusoft.gsqlparser.stmt.TInsertSqlStatement;
import gudusoft.gsqlparser.stmt.TLoopStmt;
import gudusoft.gsqlparser.stmt.TMergeSqlStatement;
import gudusoft.gsqlparser.stmt.TOpenforStmt;
import gudusoft.gsqlparser.stmt.TSelectSqlStatement;
import gudusoft.gsqlparser.stmt.TStoredProcedureSqlStatement;
import gudusoft.gsqlparser.stmt.mssql.TMssqlDeclare;
import gudusoft.gsqlparser.stmt.oracle.TPlsqlCreatePackage;
import gudusoft.gsqlparser.util.SQLUtil;

import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

public class ModelFactory {

        private ModelBindingManager modelManager;

        public ModelFactory(ModelBindingManager modelManager) {
                this.modelManager = modelManager;
        }

        public ResultSet createResultSet(TSelectSqlStatement select, boolean isTarget) {
                if (select.getResultColumnList() != null) {
                        if (modelManager.getModel(select.getResultColumnList()) instanceof ResultSet) {
                                return (ResultSet) modelManager.getModel(select.getResultColumnList());
                        }
                        SelectResultSet resultSet = new SelectResultSet(select, isTarget);
                        modelManager.bindModel(select.getResultColumnList(), resultSet);
                        return resultSet;
                } else if (select.getTransformClause() != null) {
                        if (modelManager.getModel(select.getTransformClause()) instanceof ResultSet) {
                                return (ResultSet) modelManager.getModel(select.getTransformClause());
                        }
                        SelectResultSet resultSet = new SelectResultSet(select, isTarget);
                        modelManager.bindModel(select.getTransformClause(), resultSet);
                        return resultSet;
                } else
                        return null;
        }

        public ResultSet createResultSet(TParseTreeNode gspObject, boolean isTarget) {
                if (modelManager.getModel(gspObject) instanceof ResultSet) {
                        return (ResultSet) modelManager.getModel(gspObject);
                }
                ResultSet resultSet = new ResultSet(gspObject, isTarget);
                modelManager.bindModel(gspObject, resultSet);
                return resultSet;
        }

        public ResultColumn createResultColumn(ResultSet resultSet, TResultColumn resultColumn) {
                if (modelManager.getModel(resultColumn) instanceof ResultColumn) {
                        return (ResultColumn) modelManager.getModel(resultColumn);
                }
                ResultColumn column = new ResultColumn(resultSet, resultColumn);
                modelManager.bindModel(resultColumn, column);
                return column;
        }

        /**
         * STRUCT tree: the result column of {@code customer.*} when the fields of {@code customer} are not known, one
         * column for all of them. It is not a wildcard over a relation, so no relation's columns are expanded into it.
         */
        /**
         * STRUCT tree: the view column of a select item {@code customer.*} whose fields are unknown, one column standing for
         * every field of {@code customer} like its result column ({@link #createStructStarResultColumn}), not a wildcard
         * over a relation (Mantis 4827).
         */
        public TableColumn createStructStarViewColumn(Table viewModel, TObjectName column, int index, boolean determined) {
                TableColumn viewColumn = createViewColumn(viewModel, column, index, determined);
                if (viewColumn != null) {
                        viewColumn.setStarColumn(false);
                }
                return viewColumn;
        }

        public ResultColumn createStructStarResultColumn(ResultSet resultSet, TResultColumn resultColumn) {
                ResultColumn column = createResultColumn(resultSet, resultColumn);
                column.setStarColumn(false);
                return column;
        }

        /**
         * STRUCT tree: the result column of one field of {@code customer.*} when the fields of {@code customer} are known,
         * named after the field. Like {@link #createStructStarResultColumn}, it is not a wildcard over a relation.
         */
        public ResultColumn createStructFieldResultColumn(ResultSet resultSet, TResultColumn resultColumn, String field) {
                ResultColumn column = createStarResultColumn(resultSet, resultColumn, field);
                column.setStarColumn(false);
                column.setStruct(true);
                return column;
        }

        public ResultColumn createStarResultColumn(ResultSet resultSetModel, TResultColumn resultColumn,
                        String refColumnName, Column source) {
                ResultColumn result = createStarResultColumn(resultSetModel, resultColumn, refColumnName);
                result.inheritIdentifier(source);
                result.inheritStarColumn(source);
                return result;
        }

        public ResultColumn createStarResultColumn(ResultSet resultSetModel, TResultColumn resultColumn,
                        String refColumnName) {
                if (modelManager.getModel(resultColumn) instanceof LinkedHashMap) {
                        LinkedHashMap<String, ResultColumn> resultColumns = (LinkedHashMap<String, ResultColumn>) modelManager
                                        .getModel(resultColumn);
                        if (resultColumns.containsKey(refColumnName)) {
                                return resultColumns.get(refColumnName);
                        }

                        ResultColumn column = new ResultColumn(resultSetModel, resultColumn, refColumnName);
                        resultColumns.put(refColumnName, column);
                        return column;
                } else {
                        LinkedHashMap<String, ResultColumn> resultColumns = new LinkedHashMap<String, ResultColumn>();
                        ResultColumn column = new ResultColumn(resultSetModel, resultColumn, refColumnName);
                        resultColumns.put(refColumnName, column);
                        modelManager.bindModel(resultColumn, resultColumns);
                        return column;
                }
        }

        public ResultColumn createSelectSetResultColumn(ResultSet resultSet, ResultColumn resultColumn) {
                if (modelManager.getModel(resultColumn) instanceof ResultColumn) {
                        return (ResultColumn) modelManager.getModel(resultColumn);
                }
                for (int i = 0; i < resultSet.getColumns().size(); i++) {
                        ResultColumn columnModel = resultSet.getColumns().get(i);
                        if (columnModel.getIdentifierKey() != null && resultColumn.getIdentifierKey() != null
                                        ? columnModel.getIdentifierKey().equals(resultColumn.getIdentifierKey())
                                        : DlineageUtil.sameColumnPath(columnModel.getName(), resultColumn.getName())) {
                                modelManager.bindModel(resultColumn, columnModel);
                                return columnModel;
                        }
                }
                ResultColumn column = new SelectSetResultColumn(resultSet, resultColumn);
                if(resultColumn.isStruct()) {
                        column.setStruct(true);
                }
                modelManager.bindModel(resultColumn, column);
                return column;
        }

        public ResultColumn createSelectSetResultColumn(ResultSet resultSet, TResultColumn resultColumn, int index) {
                
                for (int i = 0; i < resultSet.getColumns().size(); i++) {
                        ResultColumn columnModel = resultSet.getColumns().get(i);
                        if(columnModel.getColumnObject() == resultColumn) {
                                return columnModel;
                        }
                }
                
                SelectSetResultColumn column = new SelectSetResultColumn(resultSet, resultColumn, index);
                modelManager.bindModel(resultColumn, column);
                return column;
        }

        public ResultColumn createAndBindingSelectSetResultColumn(ResultSet resultSet, TResultColumn resultColumn,
                        int index) {
                if (modelManager.getModel(resultColumn) instanceof ResultColumn) {
                        return (ResultColumn) modelManager.getModel(resultColumn);
                }
                ResultColumn column = new SelectSetResultColumn(resultSet, resultColumn, index);
                modelManager.bindModel(resultColumn, column);
                return column;
        }

        public ResultColumn createResultColumn(ResultSet resultSet, TObjectName resultColumn) {
                if (modelManager.getModel(resultColumn) instanceof ResultColumn) {
                        return (ResultColumn) modelManager.getModel(resultColumn);
                }
                if(EDbVendor.dbvoracle == ModelBindingManager.getGlobalVendor()){
                        ResultColumn column = new ResultColumn(resultSet, resultColumn);
                        modelManager.bindModel(resultColumn, column);
                        return column;
                }
                else {
                        String columnName = resultColumn.toString();
                        for (int i = 0; i < resultSet.getColumns().size(); i++) {
                                ResultColumn columnModel = resultSet.getColumns().get(i);
                                if (matchesColumn(columnModel, columnModel.getName(), resultColumn, columnName)) {
                                        modelManager.bindModel(resultColumn, columnModel);
                                        return columnModel;
                                }
                        }
                        ResultColumn column = new ResultColumn(resultSet, resultColumn);
                        modelManager.bindModel(resultColumn, column);
                        return column;
                }
        }
        
        public ResultColumn createDeterminedResultColumn(ResultSet resultSet, TObjectName resultColumn) {
                ResultColumn column = new ResultColumn(resultSet, resultColumn);
                modelManager.bindModel(resultColumn, column);
                return column;
        }

        public ResultColumn createResultColumn(ResultSet resultSet, TExpression expression) {
                if (modelManager.getModel(expression) instanceof ResultColumn) {
                        return (ResultColumn) modelManager.getModel(expression);
                }
                ResultColumn column = new ResultColumn(resultSet, expression);
                modelManager.bindModel(expression, column);
                return column;
        }

        public ResultColumn createResultColumn(ResultSet resultSet, TObjectName resultColumn, boolean forceCreate) {
                if (!forceCreate) {
                        if (modelManager.getModel(resultColumn) instanceof ResultColumn) {
                                return (ResultColumn) modelManager.getModel(resultColumn);
                        }
                }

                String columnName = resultColumn.toString();
                for (int i = 0; i < resultSet.getColumns().size(); i++) {
                        ResultColumn columnModel = resultSet.getColumns().get(i);
                        if (matchesColumn(columnModel, columnModel.getName(), resultColumn, columnName)) {
                                modelManager.bindModel(resultColumn, columnModel);
                                return columnModel;
                        }
                }

                ResultColumn column = new ResultColumn(resultSet, resultColumn);
                modelManager.bindModel(resultColumn, column);
                return column;
        }

        public FunctionResultColumn createFunctionResultColumn(Function function, TObjectName functionName) {
                if (modelManager.getModel(functionName) instanceof FunctionResultColumn) {
                        return (FunctionResultColumn) modelManager.getModel(functionName);
                }
                FunctionResultColumn column = new FunctionResultColumn(function, function.getFunctionObject(), functionName);
                modelManager.bindModel(functionName, column);
                return column;
        }

        public FunctionResultColumn createFunctionResultColumn(Function function, TWhenClauseItemList caseFunction) {
                if (modelManager.getModel(caseFunction) instanceof FunctionResultColumn) {
                        return (FunctionResultColumn) modelManager.getModel(caseFunction);
                }
                FunctionResultColumn column = new FunctionResultColumn(function, function.getFunctionObject(), caseFunction);
                modelManager.bindModel(caseFunction, column);
                return column;
        }

        public ResultColumn createMergeResultColumn(ResultSet resultSet, TObjectName resultColumn) {
                if (modelManager.getMergeModel(resultColumn) instanceof ResultColumn) {
                        return (ResultColumn) modelManager.getMergeModel(resultColumn);
                }
                ResultColumn column = new ResultColumn(resultSet, resultColumn);
                column.nameAfterWrittenAttribute(resultColumn);
                modelManager.bindMergeModel(resultColumn, column);
                return column;
        }

        public ResultColumn createUpdateResultColumn(ResultSet resultSet, TObjectName resultColumn) {
                if (modelManager.getUpdateModel(resultColumn) instanceof ResultColumn) {
                        return (ResultColumn) modelManager.getUpdateModel(resultColumn);
                }
                ResultColumn column = new ResultColumn(resultSet, resultColumn);
                column.nameAfterWrittenAttribute(resultColumn);
                modelManager.bindUpdateModel(resultColumn, column);
                return column;
        }

        public ResultColumn createResultColumn(QueryTable queryTableModel, TResultColumn resultColumn) {
                if (modelManager.getModel(resultColumn) instanceof ResultColumn) {
                        return (ResultColumn) modelManager.getModel(resultColumn);
                }
                ResultColumn column = new ResultColumn(queryTableModel, resultColumn);
                modelManager.bindModel(resultColumn, column);
                return column;
        }
        
        public Table createTableFromCreateDDL(TTable table, boolean fromDDL, String tableName) {
                if (modelManager.getCreateModel(table) instanceof Table) {
                        Table tableModel = (Table) modelManager.getCreateModel(table);
                        tableModel.setPosition(table);
                        return tableModel;
                }
                if (modelManager.getModel(table) instanceof Table) {
                        Table tableModel = (Table) modelManager.getModel(table);
                        tableModel.setPosition(table);
                        return tableModel;
                }
                if (modelManager
                                .getTableByName(DlineageUtil.getTableIdentityKey(tableName.toString())) instanceof Table) {
                        Table tableModel = (Table) modelManager.getTableByName(DlineageUtil.getTableIdentityKey(tableName.toString()));
                        tableModel.setPosition(table);
                        return tableModel;
                }
                if (modelManager.getTableByName(
                                DlineageUtil.getTableIdentityKeyWithDefaultSchema(tableName.toString())) instanceof Table) {
                        Table tableModel = (Table) modelManager
                                        .getTableByName(DlineageUtil.getTableIdentityKeyWithDefaultSchema(tableName.toString()));
                        tableModel.setPosition(table);
                        return tableModel;
                }
                Table tableModel = new Table(table, tableName);
                tableModel.setCreateTable(fromDDL);
                if (!fromDDL) {
                        Table existTable = modelManager.getTableByName(tableModel.getBindingKey());
                        if (existTable != null) {
                                return existTable;
                        }
                }
                modelManager.bindCreateModel(table, tableModel);
                if(table.getTableType() == ETableSource.unnest) {
                        
                }
                else {
                        modelManager.bindTableByName(DlineageUtil.getTableIdentityKey(tableName.toString()), tableModel);
                }
                return tableModel;
        }

        /**
         * The table of a Hive-family LATERAL VIEW whose alias names the table of another view: a table of the free name
         * {@code tableName} ({@code tmp1-1}), bound to this view, which a lookup of the view finds before its alias
         * (Mantis 4845).
         */
        /**
         * Plan section 4.3: the table of a relation a table-generating construct adds to a SELECT, a Hive-family
         * {@code LATERAL VIEW} here, keyed by its parse node and published under {@code name}. It is never looked up by
         * that name nor bound to it, so a table of the script with the same name stays a table of its own (Mantis 4890);
         * the output never merges the two ({@code xml.table.isArrayRelation}).
         */
        public Table createArrayRelationTable(TTable table, String name) {
                if (modelManager.getBoundModel(table) instanceof Table) {
                        return (Table) modelManager.getBoundModel(table);
                }
                Table tableModel = new Table(name);
                tableModel.dropPosition(); // a table built from a name has none; this one has the view's
                tableModel.setPosition(table);
                tableModel.setArrayRelation(true);
                modelManager.bindModel(table, tableModel);
                return tableModel;
        }

        public Table createTableFromCreateDDL(TTable table, boolean fromDDL) {
                if (modelManager.getCreateModel(table) instanceof Table) {
                        Table tableModel = (Table) modelManager.getCreateModel(table);
                        tableModel.setPosition(table);
                        return tableModel;
                }
                if (ModelBindingManager.getGlobalProcedure() != null && ModelBindingManager.isScopedTemporary(table)) {
                        // A declaration in this routine creates its own instance, even when a session
                        // table with the same name is visible. The caller's model must not be mutated.
                        Table tableModel = modelManager.getTemporaryMetadataModel(table);
                        if (tableModel == null) tableModel = new Table(table);
                        else tableModel.setPosition(table);
                        tableModel.setCreateTable(fromDDL, fromDDL);
                        modelManager.bindCreateModel(table, tableModel);
                        modelManager.bindTableByName(DlineageUtil.getTableIdentityKey(table.getTableName().toString()), tableModel);
                        modelManager.bindTableByName(tableModel.getBindingKey(), tableModel);
                        return tableModel;
                }
                if (modelManager.getModel(table) instanceof Table) {
                        Table tableModel = (Table) modelManager.getModel(table);
                        tableModel.setPosition(table);
                        return tableModel;
                }
                if (modelManager
                                .getTableByName(DlineageUtil.getTableIdentityKey(table.getTableName().toString())) instanceof Table) {
                        Table tableModel = (Table) modelManager.getTableByName(DlineageUtil.getTableIdentityKey(table.getTableName().toString()));
                        tableModel.setPosition(table);
                        return tableModel;
                }
                if (modelManager.getTableByName(
                                DlineageUtil.getTableIdentityKeyWithDefaultSchema(table.getTableName().toString())) instanceof Table) {
                        Table tableModel = (Table) modelManager
                                        .getTableByName(DlineageUtil.getTableIdentityKeyWithDefaultSchema(table.getTableName().toString()));
                        tableModel.setPosition(table);
                        return tableModel;
                }
                Table tableModel = new Table(table);
                tableModel.setCreateTable(fromDDL, fromDDL);
                if (!fromDDL) {
                        Table existTable = modelManager.getTableByName(tableModel.getBindingKey());
                        if (existTable != null) {
                                return existTable;
                        }
                }
                modelManager.bindCreateModel(table, tableModel);
                modelManager.bindTableByName(DlineageUtil.getTableIdentityKey(table.getTableName().toString()), tableModel);
                modelManager.bindTableByName(tableModel.getBindingKey(), tableModel);
                return tableModel;
        }

        public Table createJsonTable(TTable table) {
                String tableName = table.toString();
                if (tableName.toLowerCase(java.util.Locale.ROOT).indexOf("with") != -1) {
                        tableName = table.toString().substring(0, tableName.toLowerCase(java.util.Locale.ROOT).indexOf("with")).trim();
                }

                if (table.isLinkTable()) {
                        table = table.getLinkTable();
                }

                if (modelManager.getCreateTable(table) != null) {
                        Table tableModel = modelManager.getCreateTable(table);
                        tableModel.setPosition(table);
                        return tableModel;
                }
                if (modelManager.getModel(table) instanceof Table) {
                        Table tableModel = (Table) modelManager.getModel(table);
                        tableModel.setPosition(table);
                        return tableModel;
                }
                if (modelManager.getTableByName(DlineageUtil.getTableIdentityKey(tableName)) instanceof Table) {
                        Table tableModel = (Table) modelManager.getTableByName(DlineageUtil.getTableIdentityKey(tableName));
                        tableModel.setPosition(table);
                        return tableModel;
                }

                if (modelManager.getTableByName(DlineageUtil.getTableIdentityKeyWithDefaultSchema(tableName)) instanceof Table) {
                        Table tableModel = (Table) modelManager.getTableByName(DlineageUtil.getTableIdentityKeyWithDefaultSchema(tableName));
                        tableModel.setPosition(table);
                        return tableModel;
                }

                Table tableModel = new Table(table);
                tableModel.setName(tableName);
                modelManager.bindModel(table, tableModel);
                modelManager.bindTableByName(DlineageUtil.getTableIdentityKey(tableName), tableModel);
                return tableModel;
        }

        public Table createXmlTable(TTable table) {
                String tableName = table.toString();
                if (tableName.toLowerCase(java.util.Locale.ROOT).indexOf("with") != -1) {
                        tableName = table.toString().substring(0, tableName.toLowerCase(java.util.Locale.ROOT).indexOf("with")).trim();
                }

                if (table.isLinkTable()) {
                        table = table.getLinkTable();
                }

                if (modelManager.getCreateTable(table) != null) {
                        Table tableModel = modelManager.getCreateTable(table);
                        tableModel.setPosition(table);
                        return tableModel;
                }
                if (modelManager.getModel(table) instanceof Table) {
                        Table tableModel = (Table) modelManager.getModel(table);
                        tableModel.setPosition(table);
                        return tableModel;
                }
                if (modelManager.getTableByName(DlineageUtil.getTableIdentityKey(tableName)) instanceof Table) {
                        Table tableModel = (Table) modelManager.getTableByName(DlineageUtil.getTableIdentityKey(tableName));
                        tableModel.setPosition(table);
                        return tableModel;
                }

                if (modelManager.getTableByName(DlineageUtil.getTableIdentityKeyWithDefaultSchema(tableName)) instanceof Table) {
                        Table tableModel = (Table) modelManager.getTableByName(DlineageUtil.getTableIdentityKeyWithDefaultSchema(tableName));
                        tableModel.setPosition(table);
                        return tableModel;
                }

                Table tableModel = new Table(table);
                tableModel.setName(tableName);
                modelManager.bindModel(table, tableModel);
                modelManager.bindTableByName(DlineageUtil.getTableIdentityKey(tableName), tableModel);
                return tableModel;
        }

        public Table createTable(TTable table, TObjectName tableBinding) {
                Table tableModel = createTable(table);
                modelManager.bindModel(table, tableModel);
                modelManager.bindTableByName(DlineageUtil.getTableIdentityKey(tableBinding.toString()), tableModel);
                return tableModel;
        }

        public Table createTable(TTable table) {
        TTable occurrence = table;
                if (table.isLinkTable()) {
                        table = table.getLinkTable();
                }

                Table tableModel = null;
                if (modelManager.getCreateTable(table) != null) {
                        tableModel = modelManager.getCreateTable(table);
                }
                if (tableModel == null && modelManager.getModel(table) instanceof Table) {
                        tableModel = (Table) modelManager.getModel(table);
                }

                String tableName = table.getTableName().toString();
                if (table.getSubquery() != null && table.getAliasClause() != null) {
                        tableName = table.getAliasClause().toString();
                }

                if (tableModel == null
                                && modelManager.getTableByName(DlineageUtil.getTableIdentityKey(tableName)) instanceof Table) {
                        tableModel = modelManager.visibleTemporaryModel(table, modelManager.getTableByName(DlineageUtil.getTableIdentityKey(tableName)));
                }

                if (tableModel == null && modelManager
                                .getTableByName(DlineageUtil.getTableIdentityKeyWithDefaultSchema(tableName)) instanceof Table) {
                        tableModel = modelManager.visibleTemporaryModel(table, modelManager.getTableByName(DlineageUtil.getTableIdentityKeyWithDefaultSchema(tableName)));
                }

                if (tableModel != null) {
                        if (table.getAliasClause() != null) {
                                tableModel.setAlias(table.getAliasName());
                        }
                        tableModel.setCurrentAlias(table.getAliasName());
                        modelManager.updateTableAliasMap(table);
                        tableModel.setPosition(table);
                        return modelManager.observeCommentOccurrence(occurrence, tableModel);
                }

                tableModel = new Table(table);
                Table existTable = modelManager.visibleTemporaryModel(table,
                                modelManager.getTableByName(tableModel.getBindingKey()));
                if (existTable != null) {
                        return modelManager.observeCommentOccurrence(occurrence, existTable);
                }
                modelManager.bindModel(table, tableModel);
                modelManager.bindTableByName(DlineageUtil.getTableIdentityKey(tableName), tableModel);
                modelManager.bindTableByName(tableModel.getBindingKey(), tableModel);

                appendTableColumns(tableModel);

                return modelManager.observeCommentOccurrence(occurrence, tableModel);
        }

        protected void appendTableColumns(Table tableModel) {
                TCustomSqlStatement stmt = ModelBindingManager.getGlobalStmtStack().peek();
                if (stmt instanceof TCreateTableSqlStatement || stmt instanceof TCreateViewSqlStatement) {
                        return;
                }
                if (stmt instanceof TInsertSqlStatement && ((TInsertSqlStatement) stmt).getColumnList() != null) {
                        return;
                }
                TTable origin = tableModel.getTableObject();
                if (origin != null && origin.getEffectType() == ETableEffectType.tetSelectInto
                                && origin.getSqlEnv() instanceof ProcedureEnvironment) return;
                if (origin != null && origin.isResolved() && origin.getSqlEnv() instanceof ProcedureEnvironment) {
                        TSQLTable metadata = origin.getResolvedTable();
                        if (metadata != null && !metadata.getColumnList().isEmpty()) {
                                for (String column : metadata.getColumns(true)) {
                                        TableColumn model = createCatalogTableColumn(tableModel, column);
                                        // Catalog column spellings have no token span. Use a real reference
                                        // (including the star being expanded), or leave the position unknown.
                                        model.setStartPosition(null);
                                        model.setEndPosition(null);
                                        for (TObjectName reference : origin.getLinkedColumns()) {
                                                boolean star = reference.getPartToken() != null
                                                                && reference.getPartToken().tokentype == gudusoft.gsqlparser.ETokenType.ttasterisk;
                                                if (star || SQLUtil.sameName(origin.dbvendor,
                                                                gudusoft.gsqlparser.sqlenv.ESQLDataObjectType.dotColumn, column, reference.getColumnNameOnly())) {
                                                        TableColumnRelationshipElement occurrence = new TableColumnRelationshipElement(model, null, reference);
                                                        model.setStartPosition(occurrence.getReferenceStartPosition());
                                                        model.setEndPosition(occurrence.getReferenceEndPosition());
                                                        if (model.getStartPosition() != null) break;
                                                }
                                        }
                                }
                                tableModel.setFromDDL(true);
                                tableModel.setCreateTable(true);
                        }
                        return;
                }
                if (ModelBindingManager.getGlobalSQLEnv() != null) {
                        // Ask the environment with the name as WRITTEN: same qualification, delimiters kept.
                        // getTableFullName is dlineage's display/matching name and removes delimiters, so it
                        // must never be a catalog fallback. If "Orders" is absent, retrying as the unquoted
                        // word Orders changes its Oracle identity to ORDERS and attaches another table's
                        // columns to a reference that the catalog does not contain.
                        ArrayList<String> columns = ModelBindingManager.getGlobalSQLEnv()
                                        .getColumnsInTable(DlineageUtil.getTableFullNameAsWritten(tableModel.getName()), true);
                        if (columns != null && !columns.isEmpty()) {
                                for (String column : columns) {
                                        if (SQLUtil.isEmpty(column)) {
                                                continue;
                                        }
                                        createCatalogTableColumn(tableModel, column);
                                }
                                tableModel.setFromDDL(true);
                                tableModel.setCreateTable(true);
                        }
                }
        }

        public Table createTriggerOnTable(TTable table) {
                if (modelManager.getCreateTable(table) != null) {
                        Table tableModel = modelManager.getCreateTable(table);
                        tableModel.setPosition(table);
                        return tableModel;
                }
                if (modelManager.getModel(table) instanceof Table) {
                        Table tableModel = (Table) modelManager.getModel(table);
                        tableModel.setPosition(table);
                        return tableModel;
                }
                if (modelManager
                                .getTableByName(DlineageUtil.getTableIdentityKey(table.getTableName().toString())) instanceof Table) {
                        Table tableModel = (Table) modelManager.getTableByName(DlineageUtil.getTableIdentityKey(table.getTableName().toString()));
                        tableModel.setPosition(table);
                        return tableModel;
                }
                if (modelManager.getTableByName(
                                DlineageUtil.getTableIdentityKeyWithDefaultSchema(table.getTableName().toString())) instanceof Table) {
                        Table tableModel = (Table) modelManager.getTableByName(DlineageUtil.getTableIdentityKeyWithDefaultSchema(table.getTableName().toString()));
                        tableModel.setPosition(table);
                        return tableModel;
                }
                Table tableModel = new Table(table);
                Table existTable = modelManager.getTableByName(tableModel.getBindingKey());
                if (existTable != null) {
                        return existTable;
                }
                modelManager.bindModel(table, tableModel);
                modelManager.bindTableByName(DlineageUtil.getTableIdentityKey(table.getTableName().toString()), tableModel);
                modelManager.bindTableByName(tableModel.getBindingKey(), tableModel);
                return tableModel;
        }

        public Table createTableByName(TObjectName tableName) {
                return createTableByName(tableName, false);
        }

        /**
         * The relation a {@code %TYPE} anchor's qualifier names ({@code rec.field%TYPE}, {@code tab.col%TYPE}): a one-part
         * qualifier may be a record or cursor declared in scope, which answers before a table of the same name, as PL/SQL
         * scoping does.
         */
        public Table createTypeAnchor(TObjectName qualifier) {
                return createTableByName(qualifier, true, qualifier.getSchemaToken() == null);
        }

        public Table createTableByName(TObjectName tableName, boolean create) {
                return createTableByName(tableName, create, false);
        }

        private Table createTableByName(TObjectName tableName, boolean create, boolean anchor) {
                if (!ModelBindingManager.getGlobalStmtStack().isEmpty()) {
                        for (TTable target : ModelBindingManager.getGlobalStmtStack().peek().tables) {
                                if (target.getTableName() == tableName
                                                && target.getSqlEnv() instanceof ProcedureEnvironment
                                                && target.getEffectType() == ETableEffectType.tetSelectInto) {
                                        return createTable(target);
                                }
                        }
                }
                // A relation name: the table path, else a local relation (UPDATE @t, OUTPUT INTO @t); an anchor's local first.
                Table bound = modelManager.resolveMixedRelation(tableName.toString(),
                                modelManager.getTableByName(DlineageUtil.getTableIdentityKey(tableName.toString())), anchor);
                if (bound != null) {
                        Table tableModel = bound;
                        tableModel.setPosition(tableName);
                        return tableModel;
                }
                Table tableModel = new Table(tableName);
                Table existTable = modelManager.getTableByName(tableModel.getBindingKey());
                if (existTable != null) {
                        existTable.setPosition(tableName);
                        return existTable;
                }
                if (tableModel.getColumns() == null || tableModel.getColumns().isEmpty()) {
                        tableModel.addColumnsFromSQLEnv();
                }
                modelManager.bindTableByName(DlineageUtil.getTableIdentityKey(tableName.toString()), tableModel);
                modelManager.bindTableByName(tableModel.getBindingKey(), tableModel);
                if (create) {
                        modelManager.bindCreateModel(tableName, tableModel);
                }
                return tableModel;
        }

        /**
         * The relation a {@code %ROWTYPE} anchor names: a cursor, a record or a table. The visible local answers before a
         * table of the same name, as PL/SQL scoping does.
         */
        public Table createRowTypeAnchor(String anchorName) {
                return createTableByName(anchorName, false, true);
        }

        public Table createTableByName(String tableName, boolean create) {
                return createTableByName(tableName, create, false);
        }

        /**
         * The path node named {@code name} that {@code identity} identifies, made as needed. A file a BULK INSERT names
         * by the same text in two contexts -- under two external data sources, or built by a runtime template -- is two
         * files, so its node is bound by that identity, not by its name (Mantis 4962).
         */
        public Table createPathModel(String name, Object identity) {
                Table bound = modelManager.getTableByName(identity);
                if (bound != null) {
                        return bound;
                }
                Table tableModel = new Table(name);
                modelManager.bindTableByName(identity, tableModel);
                return tableModel;
        }

        private Table createTableByName(String tableName, boolean create, boolean anchor) {
                Table bound = modelManager.resolveMixedRelation(tableName,
                                modelManager.getTableByName(DlineageUtil.getTableIdentityKey(tableName.toString())), anchor);
                if (bound != null) {
                        return bound;
                }
                Table tableModel = new Table(tableName);
                Table existTable = modelManager.getTableByName(tableModel.getBindingKey());
                if (existTable != null) {
                        return existTable;
                }
                if (tableModel.getColumns() == null || tableModel.getColumns().isEmpty()) {
                        tableModel.addColumnsFromSQLEnv();
                }
                modelManager.bindTableByName(DlineageUtil.getTableIdentityKey(tableName.toString()), tableModel);
                modelManager.bindTableByName(tableModel.getBindingKey(), tableModel);
                if (create) {
                        modelManager.bindCreateModel(tableName, tableModel);
                }
                return tableModel;
        }

        /**
         * The model of a table named by the catalog rather than by the SQL (the base table of a catalog synonym): the
         * table the analysis holds under that name, else a new one, bound like any table. A table no SQL named has no
         * position, so a new one publishes none, for itself or for the columns the catalog gives it: not the unknown
         * position of a name-only model, not the position a synthesized column name would claim (line 1). Merged with the
         * same table from the metadata, the metadata's own coordinates stand.
         */
        public Table createCatalogNamedTable(String tableName) {
                long lastId = modelManager.TABLE_COLUMN_ID;
                Table table = createTableByName(tableName, false);
                if (table != null && table.getId() > lastId) {
                        table.dropPosition();
                        for (TableColumn column : table.getColumns()) {
                                column.setStartPosition(null);
                                column.setEndPosition(null);
                        }
                }
                return table;
        }

        public Table createStage(TObjectName stageName) {
                // Named like a table, and found by the table references that name it (SELECT FROM a stream, @stage).
                Object key = DlineageUtil.getTableIdentityKey(stageName.toString());
                if (modelManager.getTableByName(key) instanceof Table) {
                        return (Table) modelManager.getTableByName(key);
                }
                Table tableModel = new Table(stageName);
                modelManager.bindTableByName(key, tableModel);
                modelManager.bindCreateModel(stageName, tableModel);

                TObjectName stageVariableName = new TObjectName();
                stageVariableName.setString("@" + stageName.getColumnNameOnly());
                modelManager.bindCreateModel(stageVariableName, tableModel);

                return tableModel;
        }

        public Table createDataSource(TObjectName dataSourceName) {
                // Named like a table, and found by the table references that name it (SELECT FROM a stream, @stage).
                Object key = DlineageUtil.getTableIdentityKey(dataSourceName.toString());
                if (modelManager.getTableByName(key) instanceof Table) {
                        return (Table) modelManager.getTableByName(key);
                }
                Table tableModel = new Table(dataSourceName);
                tableModel.setDataSource(true);
                modelManager.bindTableByName(key, tableModel);
                modelManager.bindCreateModel(dataSourceName, tableModel);

                return tableModel;
        }

        public Table createStream(TObjectName streamName) {
                // Named like a table, and found by the table references that name it (SELECT FROM a stream, @stage).
                Object key = DlineageUtil.getTableIdentityKey(streamName.toString());
                if (modelManager.getTableByName(key) instanceof Table) {
                        return (Table) modelManager.getTableByName(key);
                }
                Table tableModel = new Table(streamName);
                tableModel.setStream(true);
                modelManager.bindTableByName(key, tableModel);
                modelManager.bindCreateModel(streamName, tableModel);
                return tableModel;
        }

        public Table createConstantsTable(TCustomSqlStatement stmt) {
                stmt = DlineageUtil.getTopStmt(stmt);
                String sqlHash = String.valueOf(stmt.hashCode());
                if (modelManager.getTableByName(sqlHash) instanceof Table) {
                        return (Table) modelManager.getTableByName(sqlHash);
                }
                Table tableModel = new Table("SQL_CONSTANTS");
                tableModel.setConstant(true);
                modelManager.bindTableByName(sqlHash, tableModel);
                modelManager.bindCreateModel(sqlHash, tableModel);
                return tableModel;
        }
        
        public Table createConstantsTable(String sqlHash) {
                if (modelManager.getTableByName(sqlHash) instanceof Table) {
                        return (Table) modelManager.getTableByName(sqlHash);
                }
                Table tableModel = new Table("SQL_CONSTANTS");
                tableModel.setConstant(true);
                modelManager.bindTableByName(sqlHash, tableModel);
                modelManager.bindCreateModel(sqlHash, tableModel);
                return tableModel;
        }

        /**
         * The relation of a declared JSON variable OPENJSON reads: the variable already declared in the declaration's own
         * scope, else a new relation there.
         */
        public Table createJsonVariable(TObjectName jsonVariable) {
                LocalSymbolKey key = localKey(LocalSymbolNames.baseName(jsonVariable), LocalSymbolKey.Kind.VARIABLE);
                Table existing = modelManager.getLocalSymbol(key);
                if (existing != null) {
                        return existing;
                }
                Table tableModel = new Table(jsonVariable);
                modelManager.publishLocalSymbol(key, tableModel);
                modelManager.bindCreateModel(jsonVariable, tableModel);
                return tableModel;
        }

        public Alias createAlias(TAliasClause aliasClause) {
                if (modelManager.getModel(aliasClause) instanceof Alias) {
                        return (Alias) modelManager.getModel(aliasClause);
                }

                Alias alias = new Alias(aliasClause);
                modelManager.bindModel(aliasClause, alias);

                return alias;
        }

        public Function createFunction(TFunctionCall functionCall) {
                if (modelManager.getModel(functionCall) instanceof Function) {
                        return (Function) modelManager.getModel(functionCall);
                }

                Function function = new Function(functionCall);
                function.setDetermined(false);
                modelManager.bindModel(functionCall, function);

                return function;
        }

        public Function createFunction(TObjectName functionName) {
                if (modelManager.getModel(functionName) instanceof Function) {
                        return (Function) modelManager.getModel(functionName);
                }

                Function function = new Function(functionName);
                function.setDetermined(false);
                modelManager.bindModel(functionName, function);

                return function;
        }

        public Function createFunction(TCaseExpression caseExpression) {
                if (modelManager.getModel(caseExpression) instanceof Function) {
                        return (Function) modelManager.getModel(caseExpression);
                }

                Function function = new Function(caseExpression);
                modelManager.bindModel(caseExpression, function);

                return function;
        }

        public QueryTable createQueryTable(TTable table) {
                QueryTable tableModel = null;

                if (table.getCTE() != null) {
                        if (modelManager.getModel(table.getCTE()) instanceof QueryTable) {
                                return (QueryTable) modelManager.getModel(table.getCTE());
                        }

                        tableModel = new QueryTable(table);

                        modelManager.bindModel(table.getCTE(), tableModel);
                } else if (table.getAliasClause() != null && table.getAliasClause().getColumns() != null) {
                        if (modelManager.getModel(table.getAliasClause().getColumns()) instanceof QueryTable) {
                                return (QueryTable) modelManager.getModel(table.getAliasClause().getColumns());
                        }

                        tableModel = new QueryTable(table);
                        TObjectNameList columns = table.getAliasClause().getColumns();
                        modelManager.bindModel(columns, tableModel);
                        for (int i = 0; i < columns.size(); i++) {
                                createResultColumn(tableModel, columns.getObjectName(i));
                        }
                        modelManager.bindModel(table, tableModel);
                } else if (table.getSubquery() != null && !table.getSubquery().isCombinedQuery()) {
                        if (modelManager.getModel(table.getSubquery().getResultColumnList()) instanceof QueryTable) {
                                return (QueryTable) modelManager.getModel(table.getSubquery().getResultColumnList());
                        }

                        tableModel = new QueryTable(table);
                        if (table.getSubquery().getResultColumnList() != null) {
                                modelManager.bindModel(table.getSubquery().getResultColumnList(), tableModel);
                        } else if (table.getSubquery().getTransformClause() != null) {
                                modelManager.bindModel(table.getSubquery().getTransformClause(), tableModel);
                        }
                        modelManager.bindModel(table, tableModel);
                } else if (table.getOutputMerge() != null) {
                        if (modelManager
                                        .getModel(table.getOutputMerge().getOutputClause().getSelectItemList()) instanceof QueryTable) {
                                return (QueryTable) modelManager.getModel(table.getOutputMerge().getOutputClause().getSelectItemList());
                        }

                        tableModel = new QueryTable(table);
                        modelManager.bindModel(table.getOutputMerge().getOutputClause().getSelectItemList(), tableModel);
                        modelManager.bindModel(table, tableModel);
                } else {
                        if (modelManager.getModel(table) instanceof QueryTable) {
                                return (QueryTable) modelManager.getModel(table);
                        }
                        
                        if(ModelBindingManager.getGlobalStmtStack().peek() instanceof TMergeSqlStatement) {
                                TMergeSqlStatement mergeStmt = (TMergeSqlStatement)ModelBindingManager.getGlobalStmtStack().peek();
                                if (modelManager.getModel(mergeStmt) instanceof QueryTable) {
                                        return (QueryTable) modelManager.getModel(mergeStmt);
                                }
                                tableModel = new QueryTable(mergeStmt);
                                modelManager.bindModel(mergeStmt, tableModel);
                        }
                        else {
                                tableModel = new QueryTable(table);
                                modelManager.bindModel(table, tableModel);
                        }
                }
                return tableModel;
        }

        /**
         * Check if a column reference is a standard qualified table.column reference
         * (not a struct field access). Returns true when tableToken matches the source table's name.
         */
        private boolean isQualifiedColumnReference(TObjectName column) {
                if (column.getSourceTable() == null || column.getTableToken() == null) {
                        return false;
                }
                String tableTokenStr = column.getTableToken().getAstext();
                TTable src = column.getSourceTable();
                String tableName = src.getTableName() != null ? src.getTableName().getTableString() : "";
                java.util.List<String> parts = gudusoft.gsqlparser.util.SQLUtil.parseNames(tableName);
                String simpleTableName = parts.isEmpty() ? tableName : parts.get(parts.size() - 1);
                if (tableTokenStr.equalsIgnoreCase(simpleTableName)) {
                        return true;
                }
                String aliasName = src.getAliasName();
                if (aliasName != null && tableTokenStr.equalsIgnoreCase(aliasName)) {
                        return true;
                }
                return false;
        }

        /**
         * The field path node a read of a field binds to: under the column the read names, the node for its path. The
         * column is the one a whole-column read of it would bind to, declared or, without DDL, inferred; the node and those
         * above it are created when the table does not have them yet, so a read binds to the same node with and without
         * DDL (Mantis 4822, STRUCT tree plan rule R1). Null when the table has no such column.
         */
        private TableColumn createFieldPathRead(Table table, TObjectName column, TSourceToken baseToken,
                        gudusoft.gsqlparser.common.structured.StructuredColumnPath read) {
                if (baseToken == null) {
                        return null;
                }
                TObjectName base = TObjectName.createObjectName(ModelBindingManager.getGlobalVendor(), EDbObjectType.column,
                                baseToken);
                TableColumn declared = createTableColumn(table, base, false);
                if (declared == null) {
                        return null;
                }
                return createFieldPath(declared.getDeclaredColumn(), read.getSegments(), column);
        }

        /**
         * STRUCT tree, BigQuery: a read of a field of the element of {@code UNNEST(items) AS i}, {@code i.item_name},
         * reads {@code items[*].item_name} of the table {@code items} belongs to. The unnest table's one column, the
         * element, comes from the element node {@code items[*]}; only BigQuery's UNNEST is linked that way
         * ({@code DataFlowAnalyzer.linkUnnestElement}). Null for any other read, and for the element itself.
         */
        private TableColumn createUnnestElementRead(Table table, TObjectName column) {
                boolean lateralView = isLateralViewElementTable(table);
                if ((table.getSubType() != SubType.unnest && !lateralView)
                                || (!lateralView && table.getColumns().size() != 1)) {
                        return null;
                }
                TableColumn unnestColumn = lateralView ? lateralViewColumnRead(table, column) : table.getColumns().get(0);
                if (unnestColumn == null) {
                        return null;
                }
                TableColumn element = unnestColumn.getSourceColumn();
                if (element == null || !element.isFieldPathNode()) {
                        // The array comes from a CTE or a derived table, whose result set carries no field nodes (Mantis 4836):
                        // a field read through the element's name, BigQuery i.item_name over UNNEST(c.items) AS i, reads the
                        // whole element i (Mantis 4835). Anything else is not placed here.
                        gudusoft.gsqlparser.common.structured.StructuredColumnPath read = column.getFieldPathRead();
                        if (read != null && read.getRootColumn() != null && !read.getSegments().isEmpty()
                                        && !DlineageUtil.isStarName(column)
                                        && DlineageUtil.sameName(ESQLDataObjectType.dotColumn, read.getRootColumn(), unnestColumn.getName())) {
                                return unnestColumn;
                        }
                        return null;
                }
                List<gudusoft.gsqlparser.common.structured.StructuredPathSegment> elementPath = element.getFieldPath().getSegments();
                if (elementPath.get(elementPath.size() - 1).getKind()
                                != gudusoft.gsqlparser.common.structured.StructuredPathSegmentKind.ARRAY_ELEMENT) {
                        return null;
                }
                gudusoft.gsqlparser.common.structured.StructuredColumnPath read = column.getFieldPathRead();
                String head = read != null ? read.getRootColumn() : DlineageUtil.rawColumnName(column);
                if (head == null || head.isEmpty() || DlineageUtil.isStarName(column) || namesUnnestOffset(table, head)) {
                        return null;
                }
                List<gudusoft.gsqlparser.common.structured.StructuredPathSegment> segments =
                                new ArrayList<gudusoft.gsqlparser.common.structured.StructuredPathSegment>(elementPath);
                if (DlineageUtil.sameName(ESQLDataObjectType.dotColumn, head, unnestColumn.getName())) {
                        // the element itself (i), or a field of it read through the element's name (BigQuery i.item_name); a
                        // LATERAL VIEW's element read whole reads the view's column, as Mantis 4845 decided
                        if (read == null) {
                                return null;
                        }
                        segments.addAll(read.getSegments());
                } else {
                        segments.add(gudusoft.gsqlparser.common.structured.StructuredPathSegment.field(head));
                        if (read != null) {
                                segments.addAll(read.getSegments());
                        }
                }
                return createFieldPath(element.getDeclaredColumn(), segments, column);
        }

        /**
         * The field path node of {@code declared} at {@code segments}, with every node above it: {@code customer},
         * {@code customer.address}, {@code customer.address.city}. Existing nodes are found by their structure, the parent
         * node and the segment, each field name compared by the analysis's identifier rules; missing ones are created with
         * the position of {@code position}.
         *
         * @param declared the declared column the path belongs to
         * @param segments the path under it
         * @param position the name whose position created nodes report
         * @return the node, {@code declared} itself for an empty path
         */
        public TableColumn createFieldPath(TableColumn declared,
                        List<gudusoft.gsqlparser.common.structured.StructuredPathSegment> segments, TObjectName position) {
                return createFieldPath(declared, segments, position, false);
        }

        /**
         * {@link #createFieldPath} for the DDL that declares the path: a node is made even where the declaration in force
         * would refuse it, because this statement is the new declaration (plan rule R10).
         */
        public TableColumn createDeclaredFieldPath(TableColumn declared,
                        List<gudusoft.gsqlparser.common.structured.StructuredPathSegment> segments, TObjectName position) {
                return createFieldPath(declared, segments, position, true);
        }

        private TableColumn createFieldPath(TableColumn declared,
                        List<gudusoft.gsqlparser.common.structured.StructuredPathSegment> segments, TObjectName position,
                        boolean declaring) {
                TableColumn node = declared;
                List<gudusoft.gsqlparser.common.structured.StructuredPathSegment> refined =
                                new ArrayList<gudusoft.gsqlparser.common.structured.StructuredPathSegment>(segments.size());
                for (int i = 0; i < segments.size(); i++) {
                        gudusoft.gsqlparser.common.structured.StructuredPathSegment segment = refineByDeclaredType(node,
                                        segments.get(i));
                        if (segment == null) {
                                // a subscript of a column or field the DDL declares as a STRUCT or a scalar (JSON): no element is
                                // proven, the read is of the node itself, as before rule R6
                                return node;
                        }
                        refined.add(segment);
                        TableColumn child = findFieldPathChild(declared.getTable(), node, segment);
                        if (!declaring && node.isFieldsDeclared() && (child == null || !child.isDeclaredField())) {
                                // the declared STRUCT type in force has no such field: no node, as for a column a declared table
                                // lacks; a field only an earlier CREATE TABLE of the name declared is not a field any more
                                return null;
                        }
                        if (child == null) {
                                child = new TableColumn(declared.getTable(), position, node,
                                                new gudusoft.gsqlparser.common.structured.StructuredColumnPath(declared.getName(),
                                                                new ArrayList<gudusoft.gsqlparser.common.structured.StructuredPathSegment>(refined)));
                        }
                        node = child;
                }
                return node;
        }

        /**
         * Plan rule R6: a subscript of a column or field the DDL declares as a MAP reads its value, of one declared as an
         * ARRAY its element; of one declared as a STRUCT or a scalar (BigQuery {@code payload[OFFSET(0)]} of a STRUCT,
         * {@code json_col['a']} of a JSON) it proves no element, and null tells the caller to stop at the node. A subscript
         * of a node no DDL declares keeps the vendor's rule; other steps are kept.
         */
        private static gudusoft.gsqlparser.common.structured.StructuredPathSegment refineByDeclaredType(TableColumn node,
                        gudusoft.gsqlparser.common.structured.StructuredPathSegment segment) {
                gudusoft.gsqlparser.common.structured.StructuredPathSegmentKind kind = segment.getKind();
                if (kind != gudusoft.gsqlparser.common.structured.StructuredPathSegmentKind.ARRAY_ELEMENT
                                && kind != gudusoft.gsqlparser.common.structured.StructuredPathSegmentKind.SUBSCRIPT) {
                        return segment;
                }
                gudusoft.gsqlparser.common.structured.DeclaredTypeNode.Kind declared = node.getDeclaredKind();
                if (declared == gudusoft.gsqlparser.common.structured.DeclaredTypeNode.Kind.MAP) {
                        return gudusoft.gsqlparser.common.structured.StructuredPathSegment.mapValue();
                }
                if (declared == gudusoft.gsqlparser.common.structured.DeclaredTypeNode.Kind.STRUCT
                                || declared == gudusoft.gsqlparser.common.structured.DeclaredTypeNode.Kind.SCALAR) {
                        return null;
                }
                if (kind == gudusoft.gsqlparser.common.structured.StructuredPathSegmentKind.SUBSCRIPT) {
                        return gudusoft.gsqlparser.common.structured.StructuredPathSegment.arrayElement();
                }
                return segment;
        }

        /** Whether {@code name} is the WITH OFFSET alias of the UNNEST {@code table} models, a column of its own. */
        private static boolean namesUnnestOffset(Table table, String name) {
                TTable unnest = table.getTableObject();
                if (unnest == null || unnest.getUnnestClause() == null || unnest.getUnnestClause().getWithOffsetAlais() == null
                                || unnest.getUnnestClause().getWithOffsetAlais().getAliasName() == null) {
                        return false;
                }
                return DlineageUtil.sameName(ESQLDataObjectType.dotColumn,
                                unnest.getUnnestClause().getWithOffsetAlais().getAliasName().toString(), name);
        }

        /**
         * Whether {@code table} is a Hive-family LATERAL VIEW whose one column is the element of an array,
         * {@code item} in {@code LATERAL VIEW explode(items) lv AS item} ({@code DataFlowAnalyzer.linkLateralViewElement}):
         * a read of a field of it reads the element's field of the array's table, as for an UNNEST (Mantis 4845).
         */
        private static boolean isLateralViewElementTable(Table table) {
                if (!table.isArrayRelation()) {
                        return false;
                }
                for (TableColumn column : table.getColumns()) {
                        if (isElementColumn(column)) {
                                return true;
                        }
                }
                return false;
        }

        /** Whether {@code column} of a LATERAL VIEW is linked to an array's element node ({@code items[*]}). */
        private static boolean isElementColumn(TableColumn column) {
                TableColumn element = column.getSourceColumn();
                if (element == null || !element.isFieldPathNode()) {
                        return false;
                }
                List<gudusoft.gsqlparser.common.structured.StructuredPathSegment> path = element.getFieldPath().getSegments();
                return !path.isEmpty() && path.get(path.size() - 1).getKind()
                                == gudusoft.gsqlparser.common.structured.StructuredPathSegmentKind.ARRAY_ELEMENT;
        }

        /** The column of a LATERAL VIEW whose field {@code column} reads, by the head of its field path; else null. */
        private static TableColumn lateralViewColumnOfFieldRead(Table table, TObjectName column) {
                gudusoft.gsqlparser.common.structured.StructuredColumnPath read = column.getFieldPathRead();
                if (read == null || read.getRootColumn() == null || DlineageUtil.isStarName(column)) {
                        return null;
                }
                for (TableColumn candidate : table.getColumns()) {
                        if (DlineageUtil.sameName(ESQLDataObjectType.dotColumn, read.getRootColumn(), candidate.getName())) {
                                return candidate;
                        }
                }
                return null;
        }

        /**
         * The element column of a LATERAL VIEW that {@code column} reads: the one its name (or the head of its field path)
         * names, when that column is linked to an element node; null otherwise (a position or a whole column).
         */
        private static TableColumn lateralViewColumnRead(Table table, TObjectName column) {
                gudusoft.gsqlparser.common.structured.StructuredColumnPath read = column.getFieldPathRead();
                String head = read != null ? read.getRootColumn() : DlineageUtil.rawColumnName(column);
                if (head == null) {
                        return null;
                }
                for (TableColumn candidate : table.getColumns()) {
                        if (isElementColumn(candidate)
                                        && DlineageUtil.sameName(ESQLDataObjectType.dotColumn, head, candidate.getName())) {
                                return candidate;
                        }
                }
                return null;
        }

        /** Whether {@code table} models an UNNEST, whichever path of the analysis modelled it. */
        private static boolean isUnnestTable(Table table) {
                return table.getSubType() == SubType.unnest || (table.getTableObject() != null
                                && table.getTableObject().getTableType() == ETableSource.unnest);
        }

        /**
         * The field path node of {@code table} directly below {@code parent} at {@code segment}, or null: found by its
         * structural identity ({@link FieldNodeKey}), the declared column and the path with each field name keyed by the
         * analysis's identifier rules.
         */
        private static TableColumn findFieldPathChild(Table table, TableColumn parent,
                        gudusoft.gsqlparser.common.structured.StructuredPathSegment segment) {
                List<gudusoft.gsqlparser.common.structured.StructuredPathSegment> path =
                                new ArrayList<gudusoft.gsqlparser.common.structured.StructuredPathSegment>();
                if (parent.isFieldPathNode()) {
                        path.addAll(parent.getFieldPath().getSegments());
                }
                path.add(segment);
                TableColumn found = table.getFieldPathNode(FieldNodeKey.of(parent.getDeclaredColumn(), path));
                return found;
        }


        public TableColumn createTableColumn(Table table, TObjectName column, boolean fromCreateTable) {
                if (modelManager.getModel(new Pair<Table, TObjectName>(table, column)) instanceof TableColumn) {
                        return (TableColumn) modelManager.getModel(new Pair<Table, TObjectName>(table, column));
                }
                // STRUCT tree: a read of a field binds to its field path node, under the column it reads
                if (!fromCreateTable && !table.isPseudo() && gudusoft.gsqlparser.nodes.structured.NestedAccessProfile.forVendor(ModelBindingManager.getGlobalVendor()).buildsDeclaredTree()) {
                        if (isUnnestTable(table) || table.isArrayRelation()) {
                                // A column of an UNNEST has no field path nodes of its own. BigQuery: a field of the element is a
                                // node of the array's table. Trino family: UNNEST expands a ROW element into a column per field, so
                                // without types it is unknown which field of the element a column is; a read of a field of it reads
                                // the column.
                                TableColumn elementField = createUnnestElementRead(table, column);
                                if (elementField == null && table.isArrayRelation()) {
                                        // a LATERAL VIEW column that is no array's element (posexplode's item, a UDTF's output): a read of
                                        // a field of it reads the column, as Mantis 4845 decided; it has no field nodes of its own
                                        elementField = lateralViewColumnOfFieldRead(table, column);
                                }
                                if (elementField != null) {
                                        modelManager.bindModel(new Pair<Table, TObjectName>(table, column), elementField);
                                        return elementField;
                                }
                        } else {
                                gudusoft.gsqlparser.common.structured.StructuredColumnPath read = column.getFieldPathRead();
                                TSourceToken baseToken = column.getFieldPathBaseToken();
                                if (read == null) {
                                        // customer.*: every field of customer, which the node of customer stands for
                                        read = column.getStructStarPath();
                                        baseToken = column.getStructStarBaseToken();
                                }
                                if (read != null) {
                                        TableColumn node = createFieldPathRead(table, column, baseToken, read);
                                        if (node != null) {
                                                modelManager.bindModel(new Pair<Table, TObjectName>(table, column), node);
                                        }
                                        return node;
                                }
                        }
                }
                // a CTAS column created from a select item that reads a field; the orphan bucket holds reads
                String fieldLeaf = fromCreateTable && !table.isPseudo() ? targetFieldLeaf(column) : null;
                // Outside the STRUCT tree (Redshift SUPER, Oracle object columns) a resolved attribute read,
                // o.customer.address.city, is a read of its BASE column customer; its last segment named no column
                // and the read was lost (Mantis 4839, 4840)
                EDbVendor attributeVendor = ModelBindingManager.getGlobalVendor();
                String attributeBase = (!fromCreateTable && (attributeVendor == EDbVendor.dbvredshift || attributeVendor == EDbVendor.dbvoracle)
                                && column.getFieldPathRead() != null && column.getFieldPathBaseToken() != null)
                                ? column.getFieldPathBaseToken().toString() : null;

                if (table.isCreateTable() && !fromCreateTable) {
                        String columnName = attributeBase != null ? attributeBase : DlineageUtil.rawColumnName(column);
                        for (int i = 0; i < table.getColumns().size(); i++) {
                                TableColumn columnModel = table.getColumns().get(i);
                                // an attribute read names its base column, so the reference's own segment is not the key to match
                                boolean matches = attributeBase != null ? DlineageUtil.columnMatches(columnModel, attributeBase)
                                                : matchesColumn(columnModel, columnModel.getName(), column, columnName);
                                if (matches) {
                                        return columnModel;
                                }
                        }

                        for (int i = 0; i < table.getColumns().size(); i++) {
                                TableColumn columnModel = table.getColumns().get(i);
                                if (columnModel.isVariant()) {
                                        columnModel.bindStarLinkColumn(column);
                                        return columnModel;
                                }
                                if (columnModel.hasStarLinkColumn()) {
                                        columnModel.bindStarLinkColumn(column);
                                        return columnModel;
                                }
                        }
                        
                        if(table.isDetermined()) {
                                return null;
                        }
                } else {
                        String columnName = fieldLeaf != null ? fieldLeaf : attributeBase != null ? attributeBase : DlineageUtil.rawColumnName(column);
                        // For BigQuery/Redshift struct fields, use full struct path for lookup
                        // to prevent collision between base column and struct field (e.g., "customer" vs "customer.name")
                        if (ModelBindingManager.getGlobalVendor() == EDbVendor.dbvbigquery
                                        || ModelBindingManager.getGlobalVendor() == EDbVendor.dbvredshift) {
                                String structName = null;
                                gudusoft.gsqlparser.resolver2.model.ColumnSource cs = column.getColumnSource();
                                if (cs != null && cs.isStructFieldAccess() && cs.hasFieldPath()) {
                                        structName = cs.getFieldPath().toFullReference(cs.getExposedName());
                                }
                                if (structName == null) {
                                        gudusoft.gsqlparser.resolver2.model.StructFieldHint hint = column.getStructFieldHint();
                                        if (hint != null && hint.getFieldPath() != null
                                                        && !isQualifiedColumnReference(column)) {
                                                structName = hint.toFullReference();
                                        }
                                }
                                if (structName == null && column.getPropertyToken() != null) {
                                        structName = column.getPartToken().getAstext() + "." + column.getPropertyToken().getAstext();
                                }
                                if (structName != null) {
                                        columnName = structName;
                                }
                        }
                        for (int i = 0; i < table.getColumns().size(); i++) {
                                TableColumn columnModel = table.getColumns().get(i);
                                boolean matches = attributeBase != null ? DlineageUtil.columnMatches(columnModel, attributeBase)
                                                : matchesColumn(columnModel, columnModel.getName(), column, columnName);
                                if (matches) {
                                        return columnModel;
                                }
                        }
                }

                if (DlineageUtil.isStarName(column) && column.getTableToken() == null) {
                        if (!fromCreateTable && table.isCreateTable()) {
                                return null;
                        }
                        for (int i = 0; i < table.getColumns().size(); i++) {
                                TableColumn columnModel = table.getColumns().get(i);
                                // The model names its wildcard column exactly "*"; a delimited "*" is a real column.
                                if (columnModel.isStarColumn()) {
                                        return columnModel;
                                }
                        }
                }

                if (table.isCreateTable() && !fromCreateTable && DlineageUtil.isWildcard(column)) {
                        return null;
                }

                if (table.isDetermined() && DlineageUtil.isWildcard(column)) {
                        return null;
                }

                TableColumn columnModel = new TableColumn(table, column);
                if (fieldLeaf != null) {
                        columnModel.name = DlineageUtil.decodeColumnIdentifier(fieldLeaf);
                } else if (attributeBase != null) {
                        columnModel.name = DlineageUtil.decodeColumnIdentifier(attributeBase);
                }
                modelManager.bindModel(new Pair<Table, TObjectName>(table, column), columnModel);

                if (DlineageUtil.isWildcard(column)) {
                        TSQLEnv sqlenv = ModelBindingManager.getGlobalSQLEnv();
                        TTable origin = table.getTableObject();
                        TSQLTable sqlTable = origin != null && origin.isResolved() && ModelBindingManager.isScopedTemporary(origin)
                                        ? origin.getResolvedTable()
                                        : sqlenv == null ? null : sqlenv.searchTable(getQualifiedTableName(table));
                        if (sqlTable != null && !sqlTable.getColumnList().isEmpty()) {
                                table.setHasSQLEnv(true);
                                if (sqlTable.getColumnList() != null) {
                                        boolean isDetermine = true;
                                        for (TSQLColumn sqlColumn : sqlTable.getColumnList()) {
                                                if(sqlColumn.getName() == null){
                                                        System.err.println("sqlevn table " + getQualifiedTableName(table) + " sqlColumn getName() returns null.");
                                                        continue;
                                                }
                                                if(sqlColumn.isUnresolvedStar()) {
                                                        isDetermine = false;
                                                        continue;
                                                }
                                                TObjectName objectName = DeclaredColumnName.ofCatalog(sqlColumn.getName(),
                                                                TSQLEnv.toLexical(ModelBindingManager.getGlobalVendor(),
                                                                                gudusoft.gsqlparser.sqlenv.ESQLDataObjectType.dotColumn, sqlColumn.getName(),
                                                                                gudusoft.gsqlparser.sqlenv.IdentifierInputForm.CATALOG_STORED));
                                                columnModel.bindStarLinkColumn(objectName);
                                        }
                                        if (isDetermine) {
                                                columnModel.setShowStar(false);
                                                columnModel.setExpandStar(true);
                                        }
                                }
                        }
                }

                return columnModel;
        }

        public static String getQualifiedTableName(Table table) {
                List<String> segments = SQLUtil.parseNames(table.name);
                boolean supportCatalog = TSQLEnv.supportCatalog(ModelBindingManager.getGlobalVendor());
                boolean supportSchema = TSQLEnv.supportSchema(ModelBindingManager.getGlobalVendor());
                if (segments.size() < 2) {
                        if (supportCatalog && supportSchema) {
                                return getDefaultDatabase() + "." + getDefaultSchema() + "." + table.name;
                        } else if (supportCatalog) {
                                return TSQLEnv.DEFAULT_DB_NAME + "." + getDefaultDatabase() + "." + table.name;
                        } else {
                                return TSQLEnv.DEFAULT_DB_NAME + "." + getDefaultSchema() + "." + table.name;
                        }
                } else if (segments.size() < 3) {
                        if (supportCatalog && supportSchema) {
                                return getDefaultDatabase() + "." + table.name;
                        } else {
                                return TSQLEnv.DEFAULT_DB_NAME + "." + table.name;
                        }
                } else {
                        return table.name;
                }
        }

        protected static String getDefaultSchema() {
                return ModelBindingManager.getEffectiveDefaultSchema();
        }

        protected static String getDefaultDatabase() {
                return ModelBindingManager.getEffectiveDefaultDatabase();
        }

        public TableColumn createStageLocation(Table table, TObjectName location) {
                if (modelManager.getModel(new Pair<Table, TObjectName>(table, location)) instanceof TableColumn) {
                        return (TableColumn) modelManager.getModel(new Pair<Table, TObjectName>(table, location));
                }

                StageLocation columnModel = new StageLocation(table, location);
                modelManager.bindModel(new Pair<Table, TObjectName>(table, location), columnModel);
                return columnModel;
        }

        public TableColumn createFileUri(Table table, TObjectName fileUri) {
                if (modelManager.getModel(new Pair<Table, TObjectName>(table, fileUri)) instanceof TableColumn) {
                        return (TableColumn) modelManager.getModel(new Pair<Table, TObjectName>(table, fileUri));
                }

                FileUri columnModel = new FileUri(table, fileUri);
                modelManager.bindModel(new Pair<Table, TObjectName>(table, fileUri), columnModel);
                return columnModel;
        }

        /**
         * The field path node at {@code segments} below {@code fileColumn}, a column of the files of a LOCATION
         * ({@link #createFileUri}), made as needed. Like the files' column, it has no place in the SQL text.
         */
        public TableColumn createFileUriFieldPath(TableColumn fileColumn,
                        List<gudusoft.gsqlparser.common.structured.StructuredPathSegment> segments) {
                TableColumn node = createFieldPath(fileColumn, segments, fileColumn.getColumnObject());
                for (TableColumn field = node; field != null && field != fileColumn; field = field.getParentColumn()) {
                        field.startPosition = fileColumn.getStartPosition();
                        field.endPosition = fileColumn.getEndPosition();
                }
                return node;
        }

        public TableColumn createVariableProperty(Table variableTable, TDeclareVariable variable) {
                if (modelManager.getModel(new Pair<Table, TDeclareVariable>(variableTable, variable)) instanceof TableColumn) {
                        return (TableColumn) modelManager.getModel(new Pair<Table, TDeclareVariable>(variableTable, variable));
                }

                TObjectName variableName = new TObjectName();
                variableName.setString("property");
                VariableProperty columnModel = new VariableProperty(variableTable, variableName, variable);
                modelManager.bindModel(new Pair<Table, TDeclareVariable>(variableTable, variable), columnModel);
                return columnModel;
        }

        public TableColumn createJsonTableColumn(Table table, TObjectName column) {
                if (modelManager.getModel(new Pair<Table, TObjectName>(table, column)) instanceof TableColumn) {
                        return (TableColumn) modelManager.getModel(new Pair<Table, TObjectName>(table, column));
                }

                JsonTableColumn columnModel = new JsonTableColumn(table, column);
                modelManager.bindModel(new Pair<Table, TObjectName>(table, column), columnModel);
                return columnModel;
        }

        public DataFlowRelationship createDataFlowRelation() {
                DataFlowRelationship relation = new DataFlowRelationship();
                modelManager.addRelation(relation);
                return relation;
        }

        public CallRelationship createCallRelation() {
                CallRelationship relation = new CallRelationship();
                modelManager.addRelation(relation);
                return relation;
        }
        
        public CrudRelationship createCrudRelation() {
                CrudRelationship relation = new CrudRelationship();
                modelManager.addRelation(relation);
                return relation;
        }

        public ERRelationship createERRelation() {
                ERRelationship relation = new ERRelationship();
                modelManager.addRelation(relation);
                return relation;
        }

        public TableColumn createTableColumn(Table table, TResultColumn column) {
                if (column.getAliasClause() != null && column.getAliasClause().getAliasName() != null) {
                        TableColumn columnModel = new TableColumn(table, column.getAliasClause().getAliasName());
                        modelManager.bindModel(column, columnModel);
                        return columnModel;
                } else if (column.getFieldAttr() != null) {
                        TableColumn columnModel = new TableColumn(table, column.getFieldAttr());
                        modelManager.bindModel(column, columnModel);
                        return columnModel;
                }
                return null;
        }

        public TableColumn createTableColumn(Table table, TConstant constant) {
                if (modelManager.getModel(new Pair<Table, TConstant>(table, constant)) instanceof TableColumn) {
                        return (TableColumn) modelManager.getModel(new Pair<Table, TConstant>(table, constant));
                }

                TableColumn columnModel = new TableColumn(table, constant);
                modelManager.bindModel(new Pair<Table, TConstant>(table, constant), columnModel);
                return columnModel;
        }

        public TableColumn createTableColumn(Table table, TFunctionCall constantFunction) {
                if (modelManager.getModel(new Pair<Table, TFunctionCall>(table, constantFunction)) instanceof TableColumn) {
                        return (TableColumn) modelManager.getModel(new Pair<Table, TFunctionCall>(table, constantFunction));
                }

                TableColumn columnModel = new TableColumn(table, constantFunction);
                modelManager.bindModel(new Pair<Table, TFunctionCall>(table, constantFunction), columnModel);
                return columnModel;
        }

        public TableColumn createTableColumn(Table table, String columnName) {
                for (TableColumn col : table.getColumns()) {
                        if (col.getName().equals(columnName)) {
                                return col;
                        }
                }
                TableColumn columnModel = new TableColumn(table, columnName);
                return columnModel;
        }

        public RecordSetRelationship createRecordSetRelation() {
                RecordSetRelationship relation = new RecordSetRelationship();
                modelManager.addRelation(relation);
                return relation;
        }

        public ImpactRelationship createImpactRelation() {
                ImpactRelationship relation = new ImpactRelationship();
                modelManager.addRelation(relation);
                return relation;
        }

        public IndirectImpactRelationship createIndirectImpactRelation() {
                IndirectImpactRelationship relation = new IndirectImpactRelationship();
                modelManager.addRelation(relation);
                return relation;
        }

        public JoinRelationship createJoinRelation() {
                JoinRelationship relation = new JoinRelationship();
                modelManager.addRelation(relation);
                return relation;
        }

        public Table createView(TCustomSqlStatement viewStmt, TObjectName viewName) {
                return createView(viewStmt, viewName, false);
        }

        public Table createView(TCustomSqlStatement viewStmt, TObjectName viewName, boolean fromCreateView) {
                if (modelManager.getViewModel(viewStmt) instanceof Table) {
                        Table table = (Table) modelManager.getViewModel(viewStmt);
                        table.setView(true);
                        table.setPosition(viewStmt);
                        return table;
                }

                if (modelManager.getTableByName(DlineageUtil.getTableIdentityKey(viewName.toString())) != null) {
                        Table table = modelManager.getTableByName(DlineageUtil.getTableIdentityKey(viewName.toString()));
                        table.setView(true);
                        table.setPosition(viewStmt);
                        return table;
                }

                Table viewModel = new Table(viewStmt, viewName);
                viewModel.setCreateTable(fromCreateView);
                viewModel.setView(true);
                modelManager.bindViewModel(viewStmt, viewModel);
                modelManager.bindTableByName(DlineageUtil.getTableIdentityKey(viewName.toString()), viewModel);
                return viewModel;
        }

        public Process createProcess(TCustomSqlStatement processStmt) {
                if (modelManager.getProcessModel(processStmt) instanceof Process) {
                        Process process = (Process) modelManager.getProcessModel(processStmt);
                        return process;
                }

                Process processModel = new Process(processStmt);
                modelManager.bindProcessModel(processStmt, processModel);
                return processModel;
        }

        public Process createProcess(TFunctionCall functionCall) {
                if (modelManager.getProcessModel(functionCall) instanceof Process) {
                        Process process = (Process) modelManager.getProcessModel(functionCall);
                        return process;
                }

                Process processModel = new Process(functionCall);
                modelManager.bindProcessModel(functionCall, processModel);
                return processModel;
        }

        public TableColumn createViewColumn(Table viewModel, TObjectName column, int index, boolean fromCreateView) {
                Pair<Table, TObjectName> bindingModel = new Pair<Table, TObjectName>(viewModel, column);
                if (modelManager.getViewModel(bindingModel) instanceof TableColumn) {
                        return (TableColumn) modelManager.getViewModel(bindingModel);
                }

                if (viewModel.isCreateTable() && !fromCreateView) {
                        if (index < viewModel.getColumns().size()) {
                                return (TableColumn) viewModel.getColumns().get(index);
                        } else {
                                return null;
                        }
                }

                TableColumn columnModel = new TableColumn(viewModel, column, index);
                modelManager.bindViewModel(bindingModel, columnModel);
                return columnModel;
        }

        private TableColumn createCatalogTableColumn(Table tableModel, String storedName) {
                EDbVendor vendor = ModelBindingManager.getGlobalVendor();
                TableColumn column = createInsertTableColumn(tableModel, DlineageUtil.catalogColumnLexical(vendor, storedName));
                // Keep the catalog display contract; the AST/key retain lexical identity separately.
                column.name = storedName;
                column.setIdentifierKey(DlineageUtil.catalogColumnKey(vendor, storedName));
                return column;
        }

        private boolean matchesColumn(Column model, String modelName, TObjectName reference, String referenceName) {
                if (model.isStarColumn() != DlineageUtil.isStarName(reference)) {
                        // A star names no column, and a column named * is not a star: they share only the display.
                        return false;
                }
                if (model.getIdentifierKey() != null && DlineageUtil.columnKey(reference) != null) {
                        return model.matchesIdentifier(reference);
                }
                // Non-identifier model names (e.g. STRUCT paths) are compared as column paths.
                return DlineageUtil.sameColumnPath(modelName, referenceName);
        }

        public TableColumn createInsertTableColumn(Table tableModel, String columnName) {
                TObjectName columnNameObject = new TObjectName();
                columnNameObject.setString(columnName);
                Pair<Table, String> bindingModel = new Pair<Table, String>(tableModel, columnName);

                if (tableModel.isCreateTable()) {
                        for (int i = 0; i < tableModel.getColumns().size(); i++) {
                                TableColumn columnModel = tableModel.getColumns().get(i);
                                if (matchesColumn(columnModel, columnModel.getName(), columnNameObject, columnName)) {
                                        modelManager.bindInsertModel(bindingModel, columnModel);
                                        return columnModel;
                                }
                        }
                }

                if (modelManager.getInsertModel(bindingModel) instanceof TableColumn) {
                        return (TableColumn) modelManager.getInsertModel(bindingModel);
                }
                TableColumn columnModel = new TableColumn(tableModel, columnNameObject);
                // This legacy overload also receives expression/display names. Only a caller
                // with explicit AST/catalog provenance may attach an identifier key.
                columnModel.setIdentifierKey(null);
                modelManager.bindInsertModel(bindingModel, columnModel);
                return columnModel;
        }

        /** Preserve the producer's identity when materializing a projected column. */
        public TableColumn createInsertTableColumn(Table tableModel, ResultColumn source) {
                if (source.getIdentifierKey() != null) {
                        for (TableColumn existing : tableModel.getColumns()) {
                                if (source.getIdentifierKey().equals(existing.getIdentifierKey())) return existing;
                        }
                        TObjectName name = new TObjectName();
                        name.setString(source.getName());
                        TableColumn column = new TableColumn(tableModel, name);
                        column.inheritIdentifier(source);
                        return column;
                }
                TableColumn column = createInsertTableColumn(tableModel, source.getName());
                column.inheritIdentifier(source);
                return column;
        }

        /**
         * The name of a column that receives a field read in the Trino family: the name the select item publishes, its
         * last field ({@code INSERT INTO t SELECT payload.address.city} writes {@code t.city}), not the column
         * {@code payload} the read comes from, which names the column only in the table it reads (Mantis 4822). Null
         * for any other name or vendor.
         */
        private static String targetFieldLeaf(TObjectName column) {
                return gudusoft.gsqlparser.nodes.structured.NestedAccessProfile.forVendor(ModelBindingManager.getGlobalVendor()).readsFieldChains() && DlineageUtil.isFieldPath(column)
                                ? DlineageUtil.fieldLeafText(column) : null;
        }

        public TableColumn createInsertTableColumn(Table tableModel, TObjectName column) {
                Pair<Table, TObjectName> bindingModel = new Pair<Table, TObjectName>(tableModel, column);
                String fieldLeaf = targetFieldLeaf(column);

                if (tableModel.isCreateTable()) {
                        String columnName = fieldLeaf != null ? fieldLeaf : DlineageUtil.rawColumnName(column);
                        for (int i = 0; i < tableModel.getColumns().size(); i++) {
                                TableColumn columnModel = tableModel.getColumns().get(i);
                                if (matchesColumn(columnModel, columnModel.getName(), column, columnName)) {
                                        modelManager.bindInsertModel(bindingModel, columnModel);
                                        return columnModel;
                                }
                        }
                }

                if (modelManager.getInsertModel(bindingModel) instanceof TableColumn) {
                        return (TableColumn) modelManager.getInsertModel(bindingModel);
                }
                TableColumn columnModel = new TableColumn(tableModel, column);
                if (fieldLeaf != null) {
                        columnModel.name = DlineageUtil.decodeColumnIdentifier(fieldLeaf);
                }
                modelManager.bindInsertModel(bindingModel, columnModel);
                return columnModel;
        }

        public TableColumn createInsertTableColumn(Table tableModel, TExpression column, int columnIndex) {
                Pair<Table, TExpression> bindingModel = new Pair<Table, TExpression>(tableModel, column);

                if (tableModel.isCreateTable()) {
                        if (columnIndex < tableModel.getColumns().size()) {
                                TableColumn columnModel = tableModel.getColumns().get(columnIndex);
                                modelManager.bindInsertModel(bindingModel, columnModel);
                                return columnModel;
                        } else {
                                return null;
                        }
                }

                if (modelManager.getInsertModel(bindingModel) instanceof TableColumn) {
                        return (TableColumn) modelManager.getInsertModel(bindingModel);
                }
                TableColumn columnModel = new TableColumn(tableModel, column, columnIndex);
                modelManager.bindInsertModel(bindingModel, columnModel);
                return columnModel;
        }

        public TableColumn createInsertTableColumn(Table tableModel, TConstant column, int columnIndex) {
                Pair<Table, TConstant> bindingModel = new Pair<Table, TConstant>(tableModel, column);

                if (tableModel.isCreateTable()) {
                        if (columnIndex < tableModel.getColumns().size()) {
                                TableColumn columnModel = tableModel.getColumns().get(columnIndex);
                                modelManager.bindInsertModel(bindingModel, columnModel);
                                return columnModel;
                        } else {
                                return null;
                        }
                }

                if (modelManager.getInsertModel(bindingModel) instanceof TableColumn) {
                        return (TableColumn) modelManager.getInsertModel(bindingModel);
                }
                TableColumn columnModel = new TableColumn(tableModel, column, columnIndex);
                modelManager.bindInsertModel(bindingModel, columnModel);
                return columnModel;
        }

        public SelectSetResultSet createSelectSetResultSet(TSelectSqlStatement stmt) {
                if (modelManager.getModel(stmt) instanceof SelectSetResultSet) {
                        return (SelectSetResultSet) modelManager.getModel(stmt);
                }
                SelectSetResultSet resultSet = new SelectSetResultSet(stmt, stmt.getParentStmt() == null);
                modelManager.bindModel(stmt, resultSet);
                return resultSet;
        }

        public ResultColumn createStarResultColumn(SelectResultSet resultSet,
                        Pair<TResultColumn, TObjectName> starColumnPair) {
                if (modelManager.getModel(starColumnPair) instanceof ResultColumn) {
                        return (ResultColumn) modelManager.getModel(starColumnPair);
                }
                ResultColumn column = new ResultColumn(resultSet, starColumnPair);
                modelManager.bindModel(starColumnPair, column);
                return column;
        }

        public Variable createCursor(TCursorDeclStmt stmt) {
                return cursorFor(stmt, stmt.getCursorName(), false, () -> new Cursor(stmt));
        }

        public Variable createCursor(TMssqlDeclare stmt) {
                return cursorFor(stmt, stmt.getCursorName(), false, () -> new Cursor(stmt));
        }

        public Variable createCursor(TLoopStmt stmt) {
                return cursorFor(stmt, stmt.getRecordName(), false, () -> new Cursor(stmt));
        }

        public Variable createCursor(TForStmt stmt) {
                return cursorFor(stmt, stmt.getLoopName(), false, () -> new Cursor(stmt));
        }

        public Variable createCursor(TOpenforStmt stmt) {
                return cursorFor(stmt, stmt.getCursorVariableName(), true, () -> new Cursor(stmt));
        }

        /**
         * A cursor by its name as written. A declaration (a loop's record included) reuses only a cursor of its own scope,
         * which it may shadow an outer one with; OPEN FOR names a cursor variable visible from the statement. Otherwise a
         * new cursor, bound in the current scope.
         */
        private Variable cursorFor(TCustomSqlStatement stmt, TObjectName cursorName, boolean reference,
                        java.util.function.Supplier<Cursor> fresh) {
                String procedureName = DlineageUtil.getProcedureParentName(stmt);
                String written = withoutColon(cursorName.toString());
                // B3 identity-first pools: cursors join the per-overload pool too
                // (codex-B3-r1 finding 7). Guarded so LEGACY never even allocates
                // the candidate Cursor — an eager throwaway would advance model IDs
                // (codex-B3-r2 finding 13); inactive in LEGACY by construction.
                if (modelManager.hasIdentityScope()) {
                        if (reference && lookupInIdentityScope(written) == null) {
                                // Not this overload's: OPEN FOR names a cursor variable of an enclosing routine or the package.
                                Table visible = modelManager.lookupVisibleLocalSymbol(localKey(written, LocalSymbolKey.Kind.CURSOR),
                                                currentStatement());
                                if (visible instanceof Variable) {
                                        return (Variable) visible;
                                }
                        }
                        Variable pooledCursor = identityScopedCursor(written, procedureName, fresh.get());
                        if (pooledCursor != null) {
                                return pooledCursor;
                        }
                }
                LocalSymbolKey key = localKey(written, LocalSymbolKey.Kind.CURSOR);
                Table existing = reference ? modelManager.lookupVisibleLocalSymbol(key, currentStatement())
                                : modelManager.getLocalSymbol(key);
                if (existing instanceof Variable) {
                        return (Variable) existing;
                }
                Cursor cursor = fresh.get();
                if (!SQLUtil.isEmpty(procedureName)) {
                        cursor.setParent(procedureName);
                }
                modelManager.publishLocalSymbol(key, cursor);
                return cursor;
        }

        /**
         * B1 (routine-summary-scc-design §3): additionally index a declared
         * formal's Variable under its routine's overload pool (its frozen scope
         * and declaration identity). Pure lookup-map addition — no model
         * binding, no new model objects — so LEGACY output is untouched by
         * construction; the identity-first lookups (slice B3) and
         * findFormalVariable are the consumers.
         */
        public void bindVariableUnderIdentityScope(Procedure procedure, String variableName,
                        Variable variable) {
                if (procedure == null || variable == null || SQLUtil.isEmpty(variableName)) {
                        return;
                }
                LocalSymbolKey key = LocalSymbolKey.of(poolScopeOf(procedure), withoutColon(variableName),
                                LocalSymbolKey.Kind.VARIABLE);
                if (key != null && key.getScope() != null && !(modelManager.getLocalSymbol(key) instanceof Variable)) {
                        modelManager.publishLocalSymbol(key, variable);
                }
        }

        /**
         * B3 (routine-summary-scc-design §3): object-level per-overload variable
         * pools. While a routine body is analyzed under the identity-first mode
         * ({@code Option.identityFirstVariablePools}), its overload pool (the
         * routine's frozen scope and declaration identity) sits on the manager's
         * pool stack and the creators key variables under it before the ordinary
         * scope — two same-named overloads get DISTINCT formal/local pools. LIFO
         * because routines nest (package members, nested blocks). Inactive in
         * LEGACY mode by construction, so every shipped path is untouched.
         */
        /** Sticky per-analysis: set on first push; gates the callee-formal
         *  identity-first lookup that runs OUTSIDE any body scope. The stack
         *  itself lives on the {@link ModelBindingManager} so DIRECT reads
         *  resolve identity-first too (codex-B3-r2 finding 7). */
        private boolean identityFirstPools = false;

        /** @deprecated a pool is keyed by its routine: use {@link #pushIdentityScope(String, Procedure)}. */
        @Deprecated
        public void pushIdentityScope(String identityScopeKey) {
                pushIdentityScope(identityScopeKey, null);
        }

        /**
         * Enters a routine body's overload pool: the routine model it belongs to (its legacy identity text is kept as
         * metadata only). Every call is matched by {@link #popIdentityScope()}.
         */
        public void pushIdentityScope(String identityScopeKey, Procedure procedure) {
                modelManager.pushIdentityScope(identityScopeKey, poolScopeOf(procedure));
                identityFirstPools = true;
        }

        /** A routine's overload-pool scope: its frozen scope and declaration identity; null without an identity. */
        private IdentityScope poolScopeOf(Procedure procedure) {
                if (procedure == null || procedure.getRoutineIdentity() == null) {
                        return null;
                }
                Object scope = LocalScopes.scopeOf(modelManager, procedure);
                return scope == null ? null : IdentityScope.of(scope, procedure.getRoutineIdentity());
        }

        private static String withoutColon(String name) {
                return name != null && name.startsWith(":") ? name.substring(1) : name;
        }

        public void popIdentityScope() {
                modelManager.popIdentityScope();
        }

        /** Identity-pool LOOKUP for the active pool ONLY.
         *  Deliberately NO ordinary-scope fallback: a fallback would hand a
         *  same-named OVERLOAD's variable back and silently re-merge the pools
         *  this mode exists to split. Null when no pool is active or on a miss. */
        private Variable lookupInIdentityScope(String written) {
                LocalSymbolKey pooled = LocalSymbolKey.of(modelManager.peekPoolScope(), written, LocalSymbolKey.Kind.VARIABLE);
                Table hit = pooled == null || pooled.getScope() == null ? null : modelManager.getLocalSymbol(pooled);
                return hit instanceof Variable ? (Variable) hit : null;
        }

        /** Identity-pool BIND: always in the active pool, and ALSO in the
         *  ordinary scope while that name is unoccupied there — ordinary reads
         *  keep working for the non-colliding common case, while a same-named
         *  overload finds the ordinary name taken and keeps its own pool
         *  (codex-B3-r1 finding 7). */
        private void bindInIdentityScope(String written, Variable variable) {
                modelManager.publishLocalSymbol(
                                LocalSymbolKey.of(modelManager.peekPoolScope(), written, LocalSymbolKey.Kind.VARIABLE), variable);
                LocalSymbolKey ordinary = localKey(written, LocalSymbolKey.Kind.VARIABLE);
                if (!(modelManager.getLocalSymbol(ordinary) instanceof Variable)) {
                        modelManager.publishLocalSymbol(ordinary, variable);
                }
        }

        /**
         * Identity-pool variable resolution for the ACTIVE pool: lookup, then on
         * a full miss create a fresh pool member. Returns null when no pool is
         * active (caller continues the ordinary path) or when {@code create} is
         * false and nothing was found.
         */
        private Variable identityScopedVariable(String written, TObjectName displayName, String displayText,
                        String procedureName, boolean create, boolean reference) {
                if (!modelManager.hasIdentityScope()) {
                        return null;
                }
                Variable found = lookupInIdentityScope(written);
                if (found == null && reference) {
                        // Not this overload's: a reference sees the enclosing routines' and the package's declarations.
                        Table visible = modelManager.lookupVisibleLocalSymbol(localKey(written, LocalSymbolKey.Kind.VARIABLE),
                                        currentStatement());
                        if (visible instanceof Variable) {
                                return (Variable) visible;
                        }
                }
                if (found != null || !create) {
                        return found;
                }
                Variable variable = displayName != null ? new Variable(displayName) : new Variable(displayText);
                if (!SQLUtil.isEmpty(procedureName)) {
                        variable.setParent(procedureName);
                }
                bindInIdentityScope(written, variable);
                return variable;
        }

        /** Identity-pool branch shared by the five cursor creators: resolve in
         *  the active pool or bind the freshly built cursor there. Null when no
         *  pool is active (creator continues its ordinary path). */
        private Variable identityScopedCursor(String written, String procedureName, Cursor freshCursor) {
                if (!modelManager.hasIdentityScope()) {
                        return null;
                }
                Variable found = lookupInIdentityScope(written);
                if (found != null) {
                        return found;
                }
                if (!SQLUtil.isEmpty(procedureName)) {
                        freshCursor.setParent(procedureName);
                }
                bindInIdentityScope(written, freshCursor);
                return freshCursor;
        }

        private TCustomSqlStatement currentStatement() {
                java.util.Stack<TCustomSqlStatement> stack = modelManager.getGlobalStmtStack();
                return stack == null || stack.isEmpty() ? null : stack.peek();
        }

        /** A local symbol's key: its name as written (a leading ':' removed) in the current statement's scope. */
        private LocalSymbolKey localKey(String name, LocalSymbolKey.Kind kind) {
                return name == null ? null
                                : LocalSymbolKey.of(LocalScopes.scopeOf(modelManager, currentStatement()), withoutColon(name), kind);
        }

        /**
         * The variable a declaration declares: the one already declared in the declaration's own scope, else a new one
         * there. A declaration never reuses an enclosing scope's variable, which it shadows.
         */
        public Variable createVariable(TObjectName variableName) {
                return variableFor(variableName, false);
        }

        /**
         * The variable a reference names: the declaration visible from the reference (its routine, the enclosing
         * routines, then its package), else a new variable in the reference's scope.
         */
        public Variable createReferencedVariable(TObjectName variableName) {
                return variableFor(variableName, true);
        }

        private Variable variableFor(TObjectName variableName, boolean reference) {
                String procedureName = DlineageUtil.getProcedureParentName(currentStatement());
                // The name the AST writes: a record field reference rec.field names its record rec.
                String written = LocalSymbolNames.baseName(variableName);

                // B3 identity-first pools: active only under the mode flag, so LEGACY
                // behavior below is untouched.
                Variable pooled = identityScopedVariable(written, variableName, null, procedureName, true, reference);
                if (pooled != null) {
                        return pooled;
                }

                LocalSymbolKey key = localKey(written, LocalSymbolKey.Kind.VARIABLE);
                Table existing = reference ? modelManager.lookupVisibleLocalSymbol(key, currentStatement())
                                : modelManager.getLocalSymbol(key);
                if (existing instanceof Variable) {
                        return (Variable) existing;
                }
                Variable variable = new Variable(variableName);
                if (!SQLUtil.isEmpty(procedureName)) {
                        variable.setParent(procedureName);
                }
                modelManager.publishLocalSymbol(key, variable);
                return variable;
        }

        public Variable createVariable(String variableName) {
                return createVariable(variableName, true);
        }

        /**
         * The variable a declaration declares (see {@link #createVariable(TObjectName)}); when {@code create} is false,
         * only one already declared in the current scope.
         */
        public Variable createVariable(String variableName, boolean create) {
                return variableFor(variableName, create, false);
        }

        /**
         * The variable a reference names (see {@link #createReferencedVariable(TObjectName)}); when {@code create} is
         * false, only a declaration visible from the reference.
         */
        public Variable createReferencedVariable(String variableName, boolean create) {
                return variableFor(variableName, create, true);
        }

        private Variable variableFor(String variableName, boolean create, boolean reference) {
                String procedureName = DlineageUtil.getProcedureParentName(currentStatement());
                String written = withoutColon(variableName);

                // B3 identity-first pools: active only under the mode flag, so LEGACY
                // behavior below is untouched.
                Variable pooled = identityScopedVariable(written, null, written, procedureName, create, reference);
                if (pooled != null) {
                        return pooled;
                }
                if (modelManager.hasIdentityScope() && !create) {
                        return null;
                }

                LocalSymbolKey key = localKey(written, LocalSymbolKey.Kind.VARIABLE);
                Table existing = reference ? modelManager.lookupVisibleLocalSymbol(key, currentStatement())
                                : modelManager.getLocalSymbol(key);
                if (existing instanceof Variable) {
                        return (Variable) existing;
                }
                if (!create) {
                        return null;
                }
                Variable variable = new Variable(variableName);
                if (!SQLUtil.isEmpty(procedureName)) {
                        variable.setParent(procedureName);
                }
                modelManager.publishLocalSymbol(key, variable);
                return variable;
        }

        /**
         * The variable {@code variableName} of {@code procedure} as a caller binds an argument to it: the routine's formal
         * (or local), in the routine's frozen scope, whatever the session's defaults are when the call is analyzed; created
         * there when {@code create}.
         */
        public Variable createVariable(Procedure procedure, String variableName, boolean create) {
                String written = withoutColon(variableName);
                // B3 identity-first pools (stage 0, mode-gated): the callee's formals
                // were keyed under ITS pool, so caller-side argument binding must
                // consult that pool first — this is what discriminates same-named
                // overloads. A complex-typed formal (records/collections carry a single
                // wildcard column) is refused: binding at that granularity would emit
                // the *-target relationship noise testIBF4RL guards against, and
                // field-level flow through such formals is produced by the body-side
                // machinery.
                if (identityFirstPools) {
                        IdentityScope pool = poolScopeOf(procedure);
                        Table identityHit = pool == null ? null
                                        : modelManager.getLocalSymbol(LocalSymbolKey.of(pool, written, LocalSymbolKey.Kind.VARIABLE));
                        if (identityHit instanceof Variable) {
                                Variable found = (Variable) identityHit;
                                if (!found.getColumns().isEmpty()
                                                && found.getColumns().get(0).isStarColumn()) {
                                        return null;
                                }
                                return found;
                        }
                }
                LocalSymbolKey key = LocalSymbolKey.of(LocalScopes.scopeOf(modelManager, procedure), written,
                                LocalSymbolKey.Kind.VARIABLE);
                Table found = modelManager.getLocalSymbol(key);
                if (found instanceof Variable) {
                        return (Variable) found;
                }
                if (!create) {
                        return null;
                }
                String displayScope = procedure.getName();
                if (procedure.getParentPackage() != null) {
                        displayScope = procedure.getParentPackage().getName() + "." + displayScope;
                }
                Variable variable = new Variable(variableName);
                if (!SQLUtil.isEmpty(displayScope)) {
                        variable.setParent(displayScope);
                }
                modelManager.publishLocalSymbol(key, variable);
                return variable;
        }

        /**
         * The formal-argument variable of {@code procedure} named
         * {@code variableName}, WITHOUT the pool stage's complex-typed refusal
         * (#695). The refusal exists because binding a whole record onto its
         * single wildcard column was noise; a caller that first materializes the
         * formal's fields from its declared type binds exactly, so it needs the
         * variable the refusal hides. Lookup only — never creates.
         */
        public Variable findFormalVariable(Procedure procedure, String variableName) {
                String written = withoutColon(variableName);
                IdentityScope pool = poolScopeOf(procedure);
                Table identityHit = pool == null ? null
                                : modelManager.getLocalSymbol(LocalSymbolKey.of(pool, written, LocalSymbolKey.Kind.VARIABLE));
                if (identityHit instanceof Variable) {
                        return (Variable) identityHit;
                }
                Table found = modelManager.getLocalSymbol(LocalSymbolKey.of(LocalScopes.scopeOf(modelManager, procedure), written,
                                LocalSymbolKey.Kind.VARIABLE));
                return found instanceof Variable ? (Variable) found : null;
        }

        public Database createDatabase(TObjectName databaseName) {
                Object key = DlineageUtil.analysisNameKey(databaseName.toString(), ESQLDataObjectType.dotCatalog);
                if (modelManager.getTableByName(key) instanceof Database) {
                        return (Database) modelManager.getTableByName(key);
                }
                Database database = new Database(databaseName);
                modelManager.bindTableByName(key, database);
                modelManager.bindModel(key, database);
                return database;
        }

        public Schema createSchema(TObjectName schemaName) {
                Object key = DlineageUtil.schemaNameKey(schemaName.toString());
                if (modelManager.getTableByName(key) instanceof Schema) {
                        return (Schema) modelManager.getTableByName(key);
                }
                Schema schema = new Schema(schemaName);
                modelManager.bindTableByName(key, schema);
                modelManager.bindModel(key, schema);
                return schema;
        }

        public PivotedTable createPivotdTable(TPivotClause pivotedTable) {
                if (modelManager.getModel(pivotedTable) instanceof PivotedTable) {
                        return (PivotedTable) modelManager.getModel(pivotedTable);
                }
                PivotedTable resultSet = new PivotedTable(pivotedTable);
                modelManager.bindModel(pivotedTable, resultSet);
                if (pivotedTable.getPivotTable() != null) {
                        modelManager.bindModel(pivotedTable.getPivotTable(), resultSet);
                }
                return resultSet;
        }

        public Procedure createProcedure(TStoredProcedureSqlStatement stmt) {
                Procedure procedure = createProcedureInternal(stmt);
                if (gudusoft.gsqlparser.dlineage.routine.RoutineShadow.enabled()) {
                        gudusoft.gsqlparser.dlineage.routine.RoutineShadow.declared(modelManager, "createProcedure", stmt, procedure);
                }
                return procedure;
        }

        private Procedure createProcedureInternal(TStoredProcedureSqlStatement stmt) {
                if (stmt == null || DlineageUtil.getProcedureOrFunctionName(stmt) == null) {
                        return null;
                }
                // The routine's three aliases (argument types, count, input count) on its name as written; a package
                // member's name is the package's name followed by its own.
                EDbVendor vendor = ModelBindingManager.getGlobalVendor();
                RoutineAliasKey name = RoutineAliasKey.written(DlineageUtil.getProcedureOrFunctionName(stmt), null);
                if (name != null && ModelBindingManager.getGlobalOraclePackage() != null) {
                        name = name.qualifiedBy(ModelBindingManager.getGlobalOraclePackage().getAliasKey());
                }
                RoutineAliasKey withArgs = name == null ? null : name.withSignature(RoutineAliases.argumentTypes(stmt, vendor));
                RoutineAliasKey withArgNum = name == null ? null : name.withSignature(RoutineAliases.argumentCount(stmt, vendor));
                RoutineAliasKey withInputArgNum = name == null ? null
                                : name.withSignature(RoutineAliases.inputArgumentCount(stmt, vendor));
                if (isOraclePackageMember() && !(modelManager.getModel(stmt) instanceof Procedure)) {
                        Procedure declared = findOraclePackageDeclaration(stmt);
                        if (declared != null) {
                                modelManager.bindModel(stmt, declared);
                                return declared;
                        }
                }
                if (this.modelManager.getModel(stmt) instanceof Procedure) {
                        return (Procedure) this.modelManager.getModel(stmt);
                }
                if (!isOraclePackageMember()) {
                        Procedure existing = this.modelManager.getProcedure(withArgs);
                        if (existing == null) {
                                existing = this.modelManager.getProcedure(withArgNum);
                        }
                        if (existing == null) {
                                existing = this.modelManager.getProcedure(withInputArgNum);
                        }
                        if (existing != null) {
                                if (existing.getProcedureObject() instanceof TObjectName) {
                                        // A call created this model by the routine's name before any definition of it was analyzed (a
                                        // later unit defines it, Mantis 4730). The definition takes it over: it describes the
                                        // definition and is indexed as the definition is when it comes first.
                                        existing.defineBy(stmt);
                                        this.modelManager.bindModel(stmt, existing);
                                        this.modelManager.bindProcedure(withArgs, existing);
                                        this.modelManager.bindProcedure(withArgNum, existing);
                                        this.modelManager.bindProcedure(withInputArgNum, existing);
                                }
                                return existing;
                        }
                }
                Procedure procedure = new Procedure(stmt);
                this.modelManager.bindModel(stmt, procedure);
                this.modelManager.bindProcedure(withArgs, procedure);
                this.modelManager.bindProcedure(withArgNum, procedure);
                this.modelManager.bindProcedure(withInputArgNum, procedure);
                return procedure;
        }

        private boolean isOraclePackageMember() {
                // The legacy name/arity aliases cannot distinguish quoted names or overloads.
                // Package members have a declaration AST identity; retain it for call binding.
                return ModelBindingManager.getGlobalVendor() == EDbVendor.dbvoracle
                                && ModelBindingManager.getGlobalOraclePackage() != null;
        }

        private Procedure findOraclePackageDeclaration(TStoredProcedureSqlStatement stmt) {
                RoutineIdentity wanted = oracleDeclarationSignature(stmt);
                for (TStoredProcedureSqlStatement prior : modelManager.getProcedures()) {
                        Object bound = modelManager.getModel(prior);
                        if (!(bound instanceof Procedure)) continue;
                        Procedure candidate = (Procedure) bound;
                        if (candidate.getParentPackage() != ModelBindingManager.getGlobalOraclePackage()) continue;
                        // Package specification/body pairs share scope; nested declarations share
                        // scope only when they have the very same enclosing routine AST.
                        if (prior.getParentStmt() != stmt.getParentStmt()
                                        && !(prior.getParentStmt() instanceof TPlsqlCreatePackage
                                        && stmt.getParentStmt() instanceof TPlsqlCreatePackage)) continue;
                        RoutineIdentity existing = oracleDeclarationSignature(prior);
                        if (wanted.getKind() == existing.getKind()
                                        && wanted.getCanonName().equals(existing.getCanonName())
                                        && wanted.getParamNames().equals(existing.getParamNames())
                                        && wanted.getParamModes().equals(existing.getParamModes())
                                        && wanted.getParamTypeNames().equals(existing.getParamTypeNames())) return candidate;
                }
                return null;
        }

        private RoutineIdentity oracleDeclarationSignature(
                        TStoredProcedureSqlStatement stmt) {
                return RoutineIdentity.of(EDbVendor.dbvoracle,
                                stmt instanceof gudusoft.gsqlparser.stmt.oracle.TPlsqlCreateFunction
                                                ? RoutineKind.PACKAGE_MEMBER_FUNCTION : RoutineKind.PACKAGE_MEMBER_PROCEDURE,
                                null, null, null, DlineageUtil.getProcedureOrFunctionName(stmt).getObjectString(),
                                stmt.getParameterDeclarations(), null);
        }

        public OraclePackage createOraclePackage(TPlsqlCreatePackage stmt) {
                if (this.modelManager.getModel(stmt) instanceof OraclePackage) {
                        return (OraclePackage) this.modelManager.getModel(stmt);
                } else {
                        OraclePackage oraclePackage = new OraclePackage(stmt);
                        this.modelManager.bindModel(stmt, oraclePackage);
                        RoutineAliasKey[] keys = packageAliasKeys(stmt);
                        if (keys != null) {
                                for (RoutineAliasKey key : keys) {
                                        this.modelManager.bindOraclePackage(key, oraclePackage);
                                }
                        }
                        return oraclePackage;
                }
        }

        /**
         * A package statement's name as written with each of its three alias suffixes (types, count, input count), as
         * {@code createOraclePackage} binds them; null when the statement has no name.
         */
        public static RoutineAliasKey[] packageAliasKeys(TStoredProcedureSqlStatement stmt) {
                EDbVendor vendor = ModelBindingManager.getGlobalVendor();
                RoutineAliasKey name = RoutineAliasKey.written(DlineageUtil.getProcedureOrFunctionName(stmt), null);
                if (name == null) {
                        return null;
                }
                return new RoutineAliasKey[] {name.withSignature(RoutineAliases.argumentTypes(stmt, vendor)),
                                name.withSignature(RoutineAliases.argumentCount(stmt, vendor)),
                                name.withSignature(RoutineAliases.inputArgumentCount(stmt, vendor))};
        }

        public Procedure createProcedureFromFunctionCall(TFunctionCall function) {
                Procedure procedure = createProcedureFromFunctionCallInternal(function);
                if (gudusoft.gsqlparser.dlineage.routine.RoutineShadow.enabled() && function != null) {
                        gudusoft.gsqlparser.dlineage.routine.RoutineShadow.declaredFromCall(modelManager, "fromFunctionCall",
                                        function.getFunctionName(), function, null, gudusoft.gsqlparser.catalog.runtime.CatalogObjectKind.FUNCTION,
                                        procedure);
                }
                return procedure;
        }

        private Procedure createProcedureFromFunctionCallInternal(TFunctionCall function) {
                if (this.modelManager.getModel(function) instanceof Procedure) {
                        return (Procedure) this.modelManager.getModel(function);
                } else {
                        Procedure procedure = new Procedure(function);
                        procedure.setType(ESqlStatementType.sstcreateprocedure);
                        this.modelManager.bindModel(function, procedure);
                        this.modelManager.bindProcedure(procedure.getAliasKey(), procedure);
                        return procedure;
                }
        }
        

        public Procedure createProcedureByName(TObjectName procedureName, int argumentSize) {
                Procedure procedure = createProcedureByNameInternal(procedureName, argumentSize);
                if (gudusoft.gsqlparser.dlineage.routine.RoutineShadow.enabled()) {
                        boolean counted = argumentSize > 0 && ModelBindingManager.getGlobalVendor() != null
                                        && gudusoft.gsqlparser.dlineage.routine.RoutineDeclaration.callsCounted(ModelBindingManager.getGlobalVendor());
                        gudusoft.gsqlparser.dlineage.routine.RoutineShadow.declaredFromCall(modelManager, "byName", procedureName,
                                        procedureName, counted ? Integer.valueOf(argumentSize) : null,
                                        gudusoft.gsqlparser.catalog.runtime.CatalogObjectKind.PROCEDURE, procedure);
                }
                return procedure;
        }

        private Procedure createProcedureByNameInternal(TObjectName procedureName, int argumentSize) {
                // The name as written, with its argument count where the vendor overloads routines by count.
                RoutineAliasKey key = RoutineAliasKey.written(procedureName, argumentSize <= 0 ? null
                                : RoutineAliases.countIfOverloads(argumentSize, ModelBindingManager.getGlobalVendor()));
                if (this.modelManager.getModel(procedureName) instanceof Procedure) {
                        return (Procedure) this.modelManager.getModel(procedureName);
                }
                Procedure existing = this.modelManager.getProcedure(key);
                if (existing != null) {
                        return existing;
                }
                Procedure procedure = new Procedure(procedureName);
                procedure.setType(ESqlStatementType.sstcreateprocedure);
                this.modelManager.bindModel(procedureName, procedure);
                this.modelManager.bindProcedure(key, procedure);
                return procedure;
        }

        public Argument createProcedureArgument(Procedure procedure, TParameterDeclaration parameter, int index) {
                if (this.modelManager.getModel(parameter) instanceof Argument) {
                        return (Argument) this.modelManager.getModel(parameter);
                } else {
                        if (procedure.getArguments() != null) {
                                for (Argument argument : procedure.getArguments()) {
                                        if (parameter.getParameterName() == null) {
                                                continue;
                                        }
                                        if (argument.getName().equals(parameter.getParameterName().toString())) {
                                                return argument;
                                        }
                                }
                        }
                        Argument argumentModel = new Argument(procedure, parameter, index);
                        this.modelManager.bindModel(parameter, argumentModel);
                        this.modelManager.bindModel(procedure.getName() + ":" + argumentModel.getName(), argumentModel);
                        return argumentModel;
                }
        }

        public Argument createProcedureArgument(OraclePackage oraclePackage, TParameterDeclaration parameter, int index) {
                if (this.modelManager.getModel(parameter) instanceof Argument) {
                        return (Argument) this.modelManager.getModel(parameter);
                } else {
                        Argument argumentModel = new Argument(oraclePackage, parameter, index);
                        this.modelManager.bindModel(parameter, argumentModel);
                        return argumentModel;
                }
        }

}