package gudusoft.gsqlparser.dlineage.dataflow.model;

import gudusoft.gsqlparser.EDbVendor;
import gudusoft.gsqlparser.ETableKind;
import gudusoft.gsqlparser.ETableSource;
import gudusoft.gsqlparser.TCustomSqlStatement;
import gudusoft.gsqlparser.TSourceToken;
import gudusoft.gsqlparser.dlineage.util.DlineageUtil;
import gudusoft.gsqlparser.dlineage.util.Pair;
import gudusoft.gsqlparser.dlineage.util.Pair3;
import gudusoft.gsqlparser.nodes.TFunctionCall;
import gudusoft.gsqlparser.nodes.TObjectName;
import gudusoft.gsqlparser.nodes.TTable;
import gudusoft.gsqlparser.sqlenv.*;
import gudusoft.gsqlparser.stmt.TCreateTableSqlStatement;
import gudusoft.gsqlparser.stmt.TCreateViewSqlStatement;
import gudusoft.gsqlparser.util.Logger;
import gudusoft.gsqlparser.util.LoggerFactory;
import gudusoft.gsqlparser.util.SQLUtil;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.util.*;

public class Table {

        private static final Logger logger = LoggerFactory.getLogger(Table.class);

        private long id;
        protected String server;
        protected String database;
        protected String schema;
        protected String name;
        protected String displayName;
        protected String fullName;
        protected Set<String> alias = new LinkedHashSet<String>();
        protected Set<Pair<Pair3<Long, Long, String>, Pair3<Long, Long, String>>> positions = new LinkedHashSet<>();
        protected String parent;
        protected Pair3<Long, Long, String> startPosition;
        protected Pair3<Long, Long, String> endPosition;
        private List<TableColumn> columns = new ArrayList<TableColumn>();
        private boolean subquery = false;

        /**
         * Set when an unqualified one-part name matches the same base table in two or
         * more schemas of the (otherwise unambiguous) default catalog and the default
         * schema holds no such object. In that case GSP must NOT fabricate a
         * non-existent default-schema object; it leaves the reference unqualified and
         * exposes the candidate set instead. See
         * docs/tmp/unqualified-name-default-schema-masks-cross-schema-ambiguity.md.
         */
        private boolean ambiguousUnqualifiedTable = false;
        private List<String> candidateTables;

        private TTable tableObject;
        private TObjectName viewName;
        private boolean isCreateTable;
        private boolean isView;
        private boolean isPseudo;
        private boolean isExternal;
        private boolean isStage;
        private boolean isSequence;
        private boolean isPath;
        private boolean isStream;
        private boolean isVariable;
        private boolean isConstant;
        private boolean isTarget;
        private String procedureId;
        private boolean isDatabase;
        private boolean isSchema;
        private boolean isDataSource;
        private String location;
        private String fileType;
        private String fileFormat;
        private List<Process> processes;
        private SubType subType;
        private String starStmt;
        private boolean hasSQLEnv = false;
        private String currentAlias;
    private boolean isDetermined;

        private boolean fromDDL;

        /**
         * How this endpoint was introduced in the analyzed SQL. The create-effect values
         * (CREATE_TABLE_DDL / SELECT_INTO / CTAS / CLONE_TABLE) are set as parse facts at
         * build time, independent of {@link #isDetermined()} — unlike {@link #fromDDL}.
         * Strictly additive; never back-fills {@link #subType}. See
         * docs/tmp/dlineage-authoritative-endpoint-classification.md.
         */
        private EndpointIntroduction endpointIntroduction = EndpointIntroduction.UNKNOWN;

        /**
         * True when this endpoint is created by the analyzed SQL (CREATE TABLE / SELECT
         * INTO / CTAS / clone target), set regardless of schema resolution.
         */
        private boolean createdInSql;

        /**
         * Pipe-joined, outermost-first list of the identifier segments of {@link #name} that
         * overlap an unresolved dynamic-SQL hole ({@code "db"}, {@code "db|name"}, ...), or
         * {@code null} when this endpoint is not runtime-templated. Written ONLY from inside a
         * dynamic-fold context by the analyzer, so a static reference to a legally delimited
         * {@code [weird@name]} is never marked. See
         * docs/tmp/dynamic-template-endpoint-provenance.md.
         */
        private String templatedParts;

        /**
         * True when the hole covers the LEADING character of the object-name segment — i.e.
         * the {@code #}/{@code ##}/{@code @} prefix that would otherwise classify this endpoint
         * as a temp table / table variable is itself runtime text, so that classification is a
         * fold artifact rather than a fact. Drives the {@link EndpointKind#DYNAMIC_TEMPLATE}
         * precedence in {@link #getEndpointKind()}.
         */
        private boolean templatedIdentity;

        private TableRelationRows relationRows = new TableRelationRows(this);

        private TCustomSqlStatement stmt;

        public Table(TCustomSqlStatement stmt, TObjectName viewName) {
                this(viewName);
                this.stmt = stmt;
                if (stmt != null) {
                        setPosition(stmt);
                }
        }

        public TCustomSqlStatement getSqlStatement() {
                return stmt;
        }
        
        public Table(TTable table, String tableName) {
                if (table == null) {
                        throw new IllegalArgumentException("Table arguments can't be null.");
                }

                id = ++ModelBindingManager.get().TABLE_COLUMN_ID;

                this.tableObject = table;

                setPosition(table);

                this.name = tableName;
                this.fullName = tableName;
                setAlias(table.getAliasName());
                setCurrentAlias(table.getAliasName());
                
                if (name.startsWith("`") && name.endsWith("`") && name.indexOf(".") != -1
                                && ModelBindingManager.getGlobalOption().getVendor() == EDbVendor.dbvbigquery) {
                        this.name = SQLUtil.trimColumnStringQuote(name);
                        this.fullName = SQLUtil.trimColumnStringQuote(fullName);
                }

                if (table.getSubquery() != null) {
                        subquery = true;
                }

                EDbVendor vendor = ModelBindingManager.getGlobalOption().getVendor();
                boolean supportCatalog = TSQLEnv.supportCatalog(vendor);
                boolean supportSchema = TSQLEnv.supportSchema(vendor);

                if (table.getTableName().getDblink() == null) {
                        this.server = DlineageUtil.getTableServer(table.getTableName().toString());
                        this.database = DlineageUtil.getTableDatabase(table.getTableName().toString());
                        this.schema = DlineageUtil.getTableSchema(table.getTableName().toString());
                }
                else {
                        if (this.server == null && !TSQLEnv.DEFAULT_SERVER_NAME.equals(getDefaultServer())) {
                                this.server = getDefaultServer();
                        }
                        this.database = SQLUtil.normalizeIdentifier(vendor, ESQLDataObjectType.dotDblink, table.getTableName().getDblink().toString());
                        if (!SQLUtil.isEmpty(table.getTableName().getSchemaString())) {
                                this.schema = table.getTableName().getSchemaString();
                        }
                        this.subType = SubType.dblink;
                        this.name = this.name.replace(table.getTableName().getDblink().toString(), this.database);
                        ModelBindingManager.get().appendDblinkTable(this.name);
                        return;
                }

                fillSchemaInfo();

                if (SQLUtil.isEmpty(this.database)) {
                        this.database = DlineageUtil.getTableDatabase(table.getTableName().toString());
                        if (SQLUtil.isEmpty(this.database) && ModelBindingManager.getGlobalOption().isShowImplicitSchema()
                                        && !SQLUtil.isEmpty(table.getTableName().getImplictDatabaseString())) {
                                this.database = table.getTableName().getImplictDatabaseString();
                        }
                }

                if (SQLUtil.isEmpty(this.schema)) {
                        this.schema = DlineageUtil.getTableSchema(table.getTableName().toString());
                        if (SQLUtil.isEmpty(this.schema) && ModelBindingManager.getGlobalOption().isShowImplicitSchema()
                                        && !SQLUtil.isEmpty(implicitSchemaOf(table.getTableName()))) {
                                this.schema = implicitSchemaOf(table.getTableName());
                        }
                }

                if (!SQLUtil.isEmpty(this.database) && SQLUtil.isEmpty(this.schema)) {
                        if (!SQLUtil.isEmpty(implicitSchemaOf(table.getTableName()))) {
                                this.schema = implicitSchemaOf(table.getTableName());
                        }
                }

                if (table.getTableType() == ETableSource.function) {
                        subType = SubType.function;
                }

                if (!supportCatalog) {
                        this.database = null;
                } else if (this.database == null && !TSQLEnv.DEFAULT_DB_NAME.equals(getDefaultDatabase())) {
                        this.database = getDefaultDatabase();
                }

                if (!supportSchema) {
                        this.schema = null;
                } else if (this.schema == null && !TSQLEnv.DEFAULT_SCHEMA_NAME.equals(getDefaultSchema())) {
                        this.schema = getDefaultSchema();
                }

                updateTableName(supportCatalog, supportSchema);

                if (this.server == null && !TSQLEnv.DEFAULT_SERVER_NAME.equals(getDefaultServer())) {
                        this.server = getDefaultServer();
                }
        }

        public Table(TTable table) {
                if (table == null) {
                        throw new IllegalArgumentException("Table arguments can't be null.");
                }

                id = ++ModelBindingManager.get().TABLE_COLUMN_ID;

                this.tableObject = table;

                setPosition(table);

                if (table.getLinkTable() != null) {
                        this.fullName = table.getLinkTable().getFullName();
                        this.name = table.getLinkTable().getName();
                        setAlias(table.getName());
                        setCurrentAlias(table.getName());
                } else if (table.getTableType() == ETableSource.function && table.getFuncCall() != null) {
                        TFunctionCall function = table.getFuncCall();
                        this.fullName = function.getFunctionName().toString();
                        this.name = function.getFunctionName().toString();
                        setAlias(table.getAliasName());
                        setCurrentAlias(table.getAliasName());
                } else {
                        if (table.getSubquery() != null && table.getAliasClause() != null) {
                                this.name = table.getAliasClause().getAliasName().toString();
                                this.subType = SubType.alias_table;
                        } else if (table.getTableName() != null) {
                                this.name = table.getTableName().toString();
                        } else {
                                this.name = table.getName();
                        }

                        this.fullName = table.getFullName();
                        if (this.fullName == null) {
                                this.fullName = this.name;
                        }

                        setAlias(table.getAliasName());
                        setCurrentAlias(table.getAliasName());
                }

                if (name.startsWith("`") && name.endsWith("`") && name.indexOf(".") != -1
                                && ModelBindingManager.getGlobalOption().getVendor() == EDbVendor.dbvbigquery) {
                        this.name = SQLUtil.trimColumnStringQuote(name);
                        this.fullName = SQLUtil.trimColumnStringQuote(fullName);
                }

                if (table.getSubquery() != null) {
                        subquery = true;
                }

                EDbVendor vendor = ModelBindingManager.getGlobalOption().getVendor();
                boolean supportCatalog = TSQLEnv.supportCatalog(vendor);
                boolean supportSchema = TSQLEnv.supportSchema(vendor);

                if (table.getTableName().getDblink() == null) {
                        this.server = DlineageUtil.getTableServer(table.getTableName().toString());
                        this.database = DlineageUtil.getTableDatabase(table.getTableName().toString());
                        this.schema = DlineageUtil.getTableSchema(table.getTableName().toString());
                }
                else {
                        if (this.server == null && !TSQLEnv.DEFAULT_SERVER_NAME.equals(getDefaultServer())) {
                                this.server = getDefaultServer();
                        }
                        this.database = SQLUtil.normalizeIdentifier(vendor, ESQLDataObjectType.dotDblink, table.getTableName().getDblink().toString());
                        if (!SQLUtil.isEmpty(table.getTableName().getSchemaString())) {
                                this.schema = table.getTableName().getSchemaString();
                        }
                        this.subType = SubType.dblink;
                        this.name = this.name.replace(table.getTableName().getDblink().toString(), this.database);
                        ModelBindingManager.get().appendDblinkTable(this.name);
                        return;
                }

                fillSchemaInfo();

                if (SQLUtil.isEmpty(this.database)) {
                        this.database = DlineageUtil.getTableDatabase(table.getTableName().toString());
                        if (SQLUtil.isEmpty(this.database) && ModelBindingManager.getGlobalOption().isShowImplicitSchema()
                                        && !SQLUtil.isEmpty(table.getTableName().getImplictDatabaseString())) {
                                this.database = table.getTableName().getImplictDatabaseString();
                        }
                }

                if (SQLUtil.isEmpty(this.schema)) {
                        this.schema = DlineageUtil.getTableSchema(table.getTableName().toString());
                        if (SQLUtil.isEmpty(this.schema) && ModelBindingManager.getGlobalOption().isShowImplicitSchema()
                                        && !SQLUtil.isEmpty(implicitSchemaOf(table.getTableName()))) {
                                this.schema = implicitSchemaOf(table.getTableName());
                        }
                }

                if (!SQLUtil.isEmpty(this.database) && SQLUtil.isEmpty(this.schema)) {
                        if (!SQLUtil.isEmpty(implicitSchemaOf(table.getTableName()))) {
                                this.schema = implicitSchemaOf(table.getTableName());
                        }
                }

                if (table.getTableType() == ETableSource.function) {
                        subType = SubType.function;
                }

                if (!supportCatalog) {
                        this.database = null;
                } else if (this.database == null && !TSQLEnv.DEFAULT_DB_NAME.equals(getDefaultDatabase())) {
                        this.database = getDefaultDatabase();
                }

                if (!supportSchema) {
                        this.schema = null;
                } else if (this.schema == null && !TSQLEnv.DEFAULT_SCHEMA_NAME.equals(getDefaultSchema())) {
                        this.schema = getDefaultSchema();
                }

                updateTableName(supportCatalog, supportSchema);

                if (this.server == null && !TSQLEnv.DEFAULT_SERVER_NAME.equals(getDefaultServer())) {
                        this.server = getDefaultServer();
                }
        }

        public void addColumnsFromSQLEnv(){
                TSQLEnv sqlEnv = ModelBindingManager.getGlobalSQLEnv();
                if (sqlEnv == null) {
                        return;
                }
                TSQLTable tsqlTable = sqlEnv.searchTable(ModelFactory.getQualifiedTableName(this));
                if (tsqlTable != null && tsqlTable.getColumnList()!=null && !tsqlTable.getColumnList().isEmpty()) {
                        for(TSQLColumn tsqlColumn: tsqlTable.getColumnList()){
                                TObjectName columnName = new TObjectName();
                                columnName.setString(tsqlColumn.getName());
                                new TableColumn(this, columnName);
                        }
                        this.setCreateTable(true);
                        this.setHasSQLEnv(true);
                }
        }

        private void fillSchemaInfo() {
                Stack<TCustomSqlStatement> stmtStack = ModelBindingManager.getGlobalStmtStack();
                if (!stmtStack.isEmpty()) {
                        TCustomSqlStatement currentStmt = stmtStack.peek();
                        TCustomSqlStatement stmt = DlineageUtil.getTopStmt(stmtStack.peek());
                        
                        String sqlComment = null;
                        try {
                                sqlComment = stmt.getCommentBeforeNode();
                        } catch (Exception e) {
                        }
                        if (!SQLUtil.isEmpty(sqlComment) && (sqlComment.indexOf("db") != -1 || sqlComment.indexOf("schema") != -1)) {
                                Properties properties = new Properties();
                                try {
                                        properties.load(
                                                        new ByteArrayInputStream(sqlComment.replace("--", "").trim().replace(",", "\n").getBytes()));
                                        if (SQLUtil.isEmpty(this.server) && properties.containsKey("db-instance")) {
                                                this.server = properties.getProperty("db-instance");
                                        }
                                        if (SQLUtil.isEmpty(this.database) && properties.containsKey("db")) {
                                                this.database = properties.getProperty("db");
                                                if(this.database.indexOf(".")!=-1) {
                                                        this.database = SQLUtil.quoteDottedName(ModelBindingManager.getGlobalOption().getVendor(), ESQLDataObjectType.dotCatalog, this.database);
                                                }
                                        }
                                        if (SQLUtil.isEmpty(this.schema) && properties.containsKey("schema")) {
                                                this.schema = properties.getProperty("schema");
                                                if(this.schema.indexOf(".")!=-1) {
                                                        this.schema = SQLUtil.quoteDottedName(ModelBindingManager.getGlobalOption().getVendor(), ESQLDataObjectType.dotSchema, this.schema);
                                                }
                                        }
                                } catch (IOException e) {
                                        logger.error("load sql comment properties failed.", e);
                                }
                        }
                        
                        if(stmt instanceof TCreateTableSqlStatement) {
                                TCreateTableSqlStatement createTableStmt = (TCreateTableSqlStatement)stmt;
                                if (createTableStmt.getTableKinds() != null 
                                                && (createTableStmt.getTableKinds().contains(ETableKind.etkTemporary) 
                                                                || createTableStmt.getTableKinds().contains(ETableKind.etkTemp)
                                                                || createTableStmt.getTableKinds().contains(ETableKind.etkLocalTemporary)
                                                                || createTableStmt.getTableKinds().contains(ETableKind.etkLocalTemp)
                                                                || createTableStmt.getTableKinds().contains(ETableKind.etkGlobalTemporary)
                                                                || createTableStmt.getTableKinds().contains(ETableKind.etkGlobalTemp)
                                                                || createTableStmt.getTableKinds().contains(ETableKind.etkScopedTemporary))) {
                                        if (this.tableObject == createTableStmt.getTargetTable()) {
                                                setSubType(SubType.temp_table);
                                                return;
                                        }
                                }
                        }
                        
                        if(currentStmt instanceof TCreateTableSqlStatement) {
                                TCreateTableSqlStatement createTableStmt = (TCreateTableSqlStatement)currentStmt;
                                if (createTableStmt.getTableKinds() != null 
                                                && (createTableStmt.getTableKinds().contains(ETableKind.etkTemporary) 
                                                                || createTableStmt.getTableKinds().contains(ETableKind.etkTemp)
                                                                || createTableStmt.getTableKinds().contains(ETableKind.etkLocalTemporary)
                                                                || createTableStmt.getTableKinds().contains(ETableKind.etkLocalTemp)
                                                                || createTableStmt.getTableKinds().contains(ETableKind.etkGlobalTemporary)
                                                                || createTableStmt.getTableKinds().contains(ETableKind.etkGlobalTemp)
                                                                || createTableStmt.getTableKinds().contains(ETableKind.etkScopedTemporary))) {
                                        if (this.tableObject == createTableStmt.getTargetTable()) {
                                                setSubType(SubType.temp_table);
                                                return;
                                        }
                                }
                        }
                        
                        if(stmt instanceof TCreateViewSqlStatement) {
                                TCreateViewSqlStatement createViewStmt = (TCreateViewSqlStatement)stmt;
                                if (createViewStmt.getTableKind() != null 
                                                && (createViewStmt.getTableKind() == (ETableKind.etkTemporary) 
                                                                || createViewStmt.getTableKind() == (ETableKind.etkTemp)
                                                                || createViewStmt.getTableKind() == (ETableKind.etkLocalTemporary)
                                                                || createViewStmt.getTableKind() == (ETableKind.etkLocalTemp)
                                                                || createViewStmt.getTableKind() == (ETableKind.etkGlobalTemporary)
                                                                || createViewStmt.getTableKind() == (ETableKind.etkGlobalTemp))) {
                                        if (this.viewName == createViewStmt.getViewName()) {
                                                setSubType(SubType.temp_table);
                                                return;
                                        }
                                }
                        }
                        
                        if(currentStmt instanceof TCreateViewSqlStatement) {
                                TCreateViewSqlStatement createViewStmt = (TCreateViewSqlStatement)currentStmt;
                                if (createViewStmt.getTableKind() != null 
                                                && (createViewStmt.getTableKind() == (ETableKind.etkTemporary) 
                                                                || createViewStmt.getTableKind() == (ETableKind.etkTemp)
                                                                || createViewStmt.getTableKind() == (ETableKind.etkLocalTemporary)
                                                                || createViewStmt.getTableKind() == (ETableKind.etkLocalTemp)
                                                                || createViewStmt.getTableKind() == (ETableKind.etkGlobalTemporary)
                                                                || createViewStmt.getTableKind() == (ETableKind.etkGlobalTemp))) {
                                        if (this.viewName == createViewStmt.getViewName()) {
                                                setSubType(SubType.temp_table);
                                                return;
                                        }
                                }
                        }
                }
                

                if (SQLUtil.isEmpty(this.database) || this.database.equals(ModelBindingManager.getGlobalDatabase())) {
                        TSQLEnv sqlEnv = ModelBindingManager.getGlobalSQLEnv();
                        if (sqlEnv == null) {
                                return;
                        }
                        int occurrence = 0;
                        int maxPriority = -1;
                        String tableDatabase = null;
                        String tableSchema = null;
                        Map<Integer, List<String>> databaseSchemasMap = new HashMap<Integer, List<String>>();
                        // Every cross-schema hit for the bare name, grouped by priority, so a name
                        // that is ambiguous across schemas (and which the rules below cannot resolve
                        // to a single winner) can be surfaced as a candidate set instead of being
                        // stamped with a non-existent default schema.
                        Map<Integer, List<String[]>> candidatesByPriority = new TreeMap<Integer, List<String[]>>();
                        for (TSQLCatalog catalog : sqlEnv.getCatalogList()) {
                                if (SQLUtil.isEmpty(schema) || this.schema.equals(ModelBindingManager.getGlobalSchema())) {
                                        for (TSQLSchema schema : catalog.getSchemaList()) {
                                                TSQLSchemaObject tsqlTable = schema.findTable(DlineageUtil.getSimpleTableName(this.name));
                                                if(tsqlTable == null){
                                                        tsqlTable = schema.findSynonyms(DlineageUtil.getSimpleTableName(this.name));
                                                }
                                                if (tsqlTable != null) {
                                                        occurrence += 1;
                                                        String candDb = quoteDottedSegment(catalog.getName());
                                                        String candSchema = quoteDottedSegment(schema.getName());
                                                        String candName = candDb + "." + candSchema + "."
                                                                        + DlineageUtil.getSimpleTableName(this.name);
                                                        int candPriority = tsqlTable.getPriority();
                                                        if (!candidatesByPriority.containsKey(candPriority)) {
                                                                candidatesByPriority.put(candPriority, new ArrayList<String[]>());
                                                        }
                                                        candidatesByPriority.get(candPriority).add(new String[] { candDb, candSchema, candName });
                                                        if (tsqlTable.getPriority() > maxPriority
                                                                        || (maxPriority > 0 && tsqlTable.getPriority() == maxPriority)) {
                                                                tableDatabase = catalog.getName();
                                                                if(tableDatabase.indexOf(".")!=-1) {
                                                                        tableDatabase = SQLUtil.quoteDottedName(ModelBindingManager.getGlobalOption().getVendor(), ESQLDataObjectType.dotCatalog, tableDatabase);
                                                                }
                                                                tableSchema = schema.getName();
                                                                if(tableSchema.indexOf(".")!=-1) {
                                                                        tableSchema = SQLUtil.quoteDottedName(ModelBindingManager.getGlobalOption().getVendor(), ESQLDataObjectType.dotSchema, tableSchema);
                                                                }
                                                                maxPriority = tsqlTable.getPriority();
                                                                if(!databaseSchemasMap.containsKey(maxPriority)) {
                                                                        databaseSchemasMap.put(maxPriority, new ArrayList<String>());
                                                                }
                                                                databaseSchemasMap.get(maxPriority).add(tableDatabase + "___" + tableSchema);
                                                        }
                                                }
                                        }
//                                      if (occurrence > 1) {
//                                              break;
//                                      }
                                } else {
                                        TSQLSchema schema = catalog.getSchema(this.schema, false);
                                        if (schema != null) {
                                                TSQLSchemaObject tsqlTable = schema.findTable(DlineageUtil.getSimpleTableName(this.name));
                                                if(tsqlTable == null){
                                                        tsqlTable = schema.findSynonyms(DlineageUtil.getSimpleTableName(this.name));
                                                }
                                                if (tsqlTable != null) {
                                                        occurrence += 1;
                                                        if (tsqlTable.getPriority() > maxPriority
                                                                        || (maxPriority > 0 && tsqlTable.getPriority() == maxPriority)) {
                                                                tableDatabase = catalog.getName();
                                                                if(tableDatabase.indexOf(".")!=-1) {
                                                                        tableDatabase = SQLUtil.quoteDottedName(ModelBindingManager.getGlobalOption().getVendor(), ESQLDataObjectType.dotCatalog, tableDatabase);
                                                                }
                                                                tableSchema = schema.getName();
                                                                if(tableSchema.indexOf(".")!=-1) {
                                                                        tableSchema = SQLUtil.quoteDottedName(ModelBindingManager.getGlobalOption().getVendor(), ESQLDataObjectType.dotSchema, tableSchema);
                                                                }
                                                                maxPriority = tsqlTable.getPriority();
                                                                if(!databaseSchemasMap.containsKey(maxPriority)) {
                                                                        databaseSchemasMap.put(maxPriority, new ArrayList<String>());
                                                                }
                                                                databaseSchemasMap.get(maxPriority).add(tableDatabase + "___" + tableSchema);
                                                        }
                                                }
                                        }
                                }
                        }
                        if (occurrence == 1 || (maxPriority > 0 && databaseSchemasMap.get(maxPriority).size() == 1)) {
                                if (this.database == null && tableDatabase != null && !TSQLEnv.DEFAULT_DB_NAME.equalsIgnoreCase(tableDatabase)) {
                                        this.database = tableDatabase;
                                }
                                if (this.schema == null && tableSchema != null && !TSQLEnv.DEFAULT_SCHEMA_NAME.equalsIgnoreCase(tableSchema)) {
                                        this.schema = tableSchema;
                                }
                        } else if ((this.schema == null || this.schema.equals(ModelBindingManager.getGlobalSchema()))
                                        && !candidatesByPriority.isEmpty()) {
                                // The existing rules could not pick a single winner and the schema is
                                // still only a default (null or the global default). Look at the
                                // top-priority group: when it holds two or more schemas AND none of
                                // them is the default schema, the unqualified name is genuinely
                                // ambiguous. Flag it and record the candidate set so the output layer
                                // can surface the reference unqualified instead of fabricating a
                                // non-existent default-schema object. A match in the default schema
                                // (e.g. an existing dbo.orders) is left to win through the normal
                                // stamping path.
                                int maxCandPriority = Collections.max(candidatesByPriority.keySet());
                                List<String[]> topCandidates = candidatesByPriority.get(maxCandPriority);
                                String defaultSchema = getDefaultSchema();
                                boolean defaultSchemaHasObject = false;
                                for (String[] cand : topCandidates) {
                                        if (cand[1] != null && DlineageUtil.sameName(ESQLDataObjectType.dotSchema, cand[1], defaultSchema)) {
                                                defaultSchemaHasObject = true;
                                                break;
                                        }
                                }
                                if (!defaultSchemaHasObject && topCandidates.size() >= 2) {
                                        List<String> candidates = new ArrayList<String>();
                                        for (String[] cand : topCandidates) {
                                                candidates.add(cand[2]);
                                        }
                                        this.candidateTables = candidates;
                                        this.ambiguousUnqualifiedTable = true;
                                }
                        }
                } else if (SQLUtil.isEmpty(this.schema) || this.schema.equals(ModelBindingManager.getGlobalSchema())) {
                        TSQLEnv sqlEnv = ModelBindingManager.getGlobalSQLEnv();
                        if (sqlEnv == null) {
                                return;
                        }
                        int occurrence = 0;
                        int maxPriority = -1;
                        String tableDatabase = null;
                        String tableSchema = null;
                        Map<Integer, List<String>> databaseSchemasMap = new HashMap<Integer, List<String>>();
                        TSQLCatalog catalog = sqlEnv.searchCatalog(this.database);
                        if (catalog != null) {
                                for (TSQLSchema schema : catalog.getSchemaList()) {
                                        TSQLSchemaObject tsqlTable = schema.findTable(DlineageUtil.getSimpleTableName(this.name));
                                        if(tsqlTable == null){
                                                tsqlTable = schema.findSynonyms(DlineageUtil.getSimpleTableName(this.name));
                                        }
                                        if (tsqlTable != null) {
                                                occurrence += 1;
                                                if (tsqlTable.getPriority() > maxPriority
                                                                || (maxPriority > 0 && tsqlTable.getPriority() == maxPriority)) {
                                                        tableDatabase = catalog.getName();
                                                        if (tableDatabase.indexOf(".") != -1) {
                                                                tableDatabase = SQLUtil.quoteDottedName(ModelBindingManager.getGlobalOption().getVendor(), ESQLDataObjectType.dotCatalog, tableDatabase);
                                                        }
                                                        tableSchema = schema.getName();
                                                        if (tableSchema.indexOf(".") != -1) {
                                                                tableSchema = SQLUtil.quoteDottedName(ModelBindingManager.getGlobalOption().getVendor(), ESQLDataObjectType.dotSchema, tableSchema);
                                                        }
                                                        maxPriority = tsqlTable.getPriority();
                                                        if(!databaseSchemasMap.containsKey(maxPriority)) {
                                                                databaseSchemasMap.put(maxPriority, new ArrayList<String>());
                                                        }
                                                        databaseSchemasMap.get(maxPriority).add(tableDatabase + "___" + tableSchema);
                                                }
                                        }
                                }
                        }

                        if (occurrence == 1 || (maxPriority > 0 && databaseSchemasMap.get(maxPriority).size() == 1)) {
                                if (this.database == null && tableDatabase != null && !TSQLEnv.DEFAULT_DB_NAME.equalsIgnoreCase(tableDatabase)) {
                                        this.database = tableDatabase;
                                }
                                if (this.schema == null && tableSchema != null && !TSQLEnv.DEFAULT_SCHEMA_NAME.equalsIgnoreCase(tableSchema)) {
                                        this.schema = tableSchema;
                                }
                        }

                        if (SQLUtil.isEmpty(this.schema) && !SQLUtil.isEmpty(this.database)) {
                                this.schema = getDefaultSchema();
                        }
                }
        }

        public Table(TObjectName tableName) {
                if (tableName == null) {
                        throw new IllegalArgumentException("Table arguments can't be null.");
                }

                id = ++ModelBindingManager.get().TABLE_COLUMN_ID;
                
                this.viewName = tableName;

                setPosition(tableName);

                this.fullName = tableName.toString();
                this.name = tableName.toString();
                if (SQLUtil.isEmpty(name)) {
                        name = tableName.toString();
                }

                if (name.startsWith("`") && name.endsWith("`") && name.indexOf(".") != -1
                                && ModelBindingManager.getGlobalOption().getVendor() == EDbVendor.dbvbigquery) {
                        this.name = SQLUtil.trimColumnStringQuote(name);
                        this.fullName = SQLUtil.trimColumnStringQuote(fullName);
                }

                this.server = DlineageUtil.getTableServer(tableName.toString());
                this.database = DlineageUtil.getTableDatabase(tableName.toString());
                this.schema = DlineageUtil.getTableSchema(tableName.toString());

                fillSchemaInfo();

                EDbVendor vendor = ModelBindingManager.getGlobalOption().getVendor();
                boolean supportCatalog = TSQLEnv.supportCatalog(vendor);
                boolean supportSchema = TSQLEnv.supportSchema(vendor);

                if (supportCatalog && SQLUtil.isEmpty(this.database)) {
                        this.database = DlineageUtil.getTableDatabase(tableName.toString());
                        if (SQLUtil.isEmpty(this.database) && ModelBindingManager.getGlobalOption().isShowImplicitSchema()
                                        && !SQLUtil.isEmpty(tableName.getImplictDatabaseString())) {
                                this.database = tableName.getImplictDatabaseString();
                        }
                }

                if (supportSchema && SQLUtil.isEmpty(this.schema)) {
                        this.schema = DlineageUtil.getTableSchema(tableName.toString());
                        if (SQLUtil.isEmpty(this.schema) && ModelBindingManager.getGlobalOption().isShowImplicitSchema()
                                        && !SQLUtil.isEmpty(implicitSchemaOf(tableName))) {
                                this.schema = implicitSchemaOf(tableName);
                        }
                }

                if (supportSchema && !SQLUtil.isEmpty(this.database) && SQLUtil.isEmpty(this.schema)) {
                        if (!SQLUtil.isEmpty(implicitSchemaOf(tableName))) {
                                this.schema = implicitSchemaOf(tableName);
                        } else {
                                this.schema = getDefaultSchema();
                        }
                }

                if (!supportCatalog) {
                        this.database = null;
                } else if (this.database == null && !TSQLEnv.DEFAULT_DB_NAME.equals(getDefaultDatabase())) {
                        this.database = getDefaultDatabase();
                }

                if (!supportSchema) {
                        this.schema = null;
                } else if (this.schema == null && !TSQLEnv.DEFAULT_SCHEMA_NAME.equals(getDefaultSchema())) {
                        this.schema = getDefaultSchema();
                }

                updateTableName(supportCatalog, supportSchema);

                if (this.server == null && !TSQLEnv.DEFAULT_SERVER_NAME.equals(getDefaultServer())) {
                        this.server = getDefaultServer();
                }
        }

        protected String getDefaultServer() {
                String defaultServer = null;
                if (ModelBindingManager.getGlobalSQLEnv() != null) {
                        defaultServer = ModelBindingManager.getGlobalSQLEnv().getDefaultServerName();
                }
                if (!SQLUtil.isEmpty(defaultServer))
                        return defaultServer;
                return TSQLEnv.DEFAULT_SERVER_NAME;
        }

        /**
         * The implicit schema stamped on {@code name}, or null when the statement
         * being analyzed has no current schema because a Snowflake
         * {@code USE <database>} unset it.
         *
         * <p>The stamp is applied by the resolvers from the TSQLEnv's default schema,
         * which is batch-global: it holds the LAST {@code USE SCHEMA} of the whole
         * script even for statements that run after a database switch invalidated it.
         * Reading it unfiltered put the previous database's schema back on names the
         * rest of this class had already left unqualified - a CREATE VIEW target
         * reported {@code D2.S1.v} while its own source table reported
         * {@code D2.DEFAULT.orders}. See GitHub #715 / MantisBT 4677.
         */
        private static String implicitSchemaOf(TObjectName name) {
                if (name == null || ModelBindingManager.isGlobalSchemaUnset()) {
                        return null;
                }
                return name.getImplictSchemaString();
        }

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

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

        /**
         * @return true when this one-part reference is ambiguous across two or more
         *         schemas and was intentionally left unqualified (no default schema
         *         stamped). The candidates are available via {@link #getCandidateTables()}.
         */
        public boolean isAmbiguousUnqualifiedTable() {
                return ambiguousUnqualifiedTable;
        }

        /**
         * @return the qualified candidate table names (e.g. {@code testdb.s1.orders},
         *         {@code testdb.s2.orders}) when this reference is ambiguous across
         *         schemas, or null when the reference resolved normally.
         */
        public List<String> getCandidateTables() {
                return candidateTables;
        }

        /**
         * Quote a catalog/schema segment the same way the surrounding resolution code
         * does (lines around the occurrence loop), so a name containing a dot is kept
         * as a single delimited segment.
         */
        private static String quoteDottedSegment(String segment) {
                if (segment != null && segment.indexOf('.') != -1) {
                        // catalog and schema segments share NAME_GROUP quote rules
                        return SQLUtil.quoteDottedName(ModelBindingManager.getGlobalOption().getVendor(),
                                        ESQLDataObjectType.dotSchema, segment);
                }
                return segment;
        }

        public Table(String tableName) {
                if (tableName == null) {
                        throw new IllegalArgumentException("Table arguments can't be null.");
                }

                id = ++ModelBindingManager.get().TABLE_COLUMN_ID;

                this.startPosition = new Pair3<Long, Long, String>(-1L, -1L, ModelBindingManager.getGlobalHash());
                this.endPosition = new Pair3<Long, Long, String>(-1L, -1L, ModelBindingManager.getGlobalHash());

                this.fullName = tableName;
                this.name = tableName;
                if (SQLUtil.isEmpty(name)) {
                        name = tableName;
                }

                if (name.startsWith("`") && name.endsWith("`") && name.indexOf(".") != -1
                                && ModelBindingManager.getGlobalOption().getVendor() == EDbVendor.dbvbigquery) {
                        this.name = SQLUtil.trimColumnStringQuote(name);
                        this.fullName = SQLUtil.trimColumnStringQuote(fullName);
                }

                EDbVendor vendor = ModelBindingManager.getGlobalOption().getVendor();
                boolean supportCatalog = TSQLEnv.supportCatalog(vendor);
                boolean supportSchema = TSQLEnv.supportSchema(vendor);

                fillSchemaInfo();

                this.server = DlineageUtil.getTableServer(tableName);

                if (supportCatalog && SQLUtil.isEmpty(this.database)) {
                        this.database = DlineageUtil.getTableDatabase(tableName);
                }
                if (supportSchema && SQLUtil.isEmpty(this.schema)) {
                        this.schema = DlineageUtil.getTableSchema(tableName);
                }
                if (supportSchema && !SQLUtil.isEmpty(this.database) && SQLUtil.isEmpty(this.schema)) {
                        this.schema = getDefaultSchema();
                }

                if (!supportCatalog) {
                        this.database = null;
                } else if (this.database == null && !TSQLEnv.DEFAULT_DB_NAME.equals(getDefaultDatabase())) {
                        this.database = getDefaultDatabase();
                }

                if (!supportSchema) {
                        this.schema = null;
                } else if (this.schema == null && !TSQLEnv.DEFAULT_SCHEMA_NAME.equals(getDefaultSchema())) {
                        this.schema = getDefaultSchema();
                }

                updateTableName(supportCatalog, supportSchema);

                if (this.server == null && !TSQLEnv.DEFAULT_SERVER_NAME.equals(getDefaultServer())) {
                        this.server = getDefaultServer();
                }
        }

        protected void updateTableName(boolean supportCatalog, boolean supportSchema) {
                List<String> segments = SQLUtil.parseNames(this.name);
                this.name = segments.get(segments.size() - 1);
                if (supportCatalog && supportSchema) {
                        StringBuilder builder = new StringBuilder();
                        if (segments.size() > 2) {
                                builder.append(segments.get(segments.size() - 3)).append(".");
                        } else {
                                if (!SQLUtil.isEmpty(this.database) && !TSQLEnv.DEFAULT_DB_NAME.equalsIgnoreCase(this.database)) {
                                        builder.append(this.database).append(".");
                                }
                        }
                        if (segments.size() > 1) {
                                builder.append(segments.get(segments.size() - 2)).append(".");
                        } else {
                                if (builder.length() > 0) {
                                        if (this.schema == null) {
                                                if (ModelBindingManager.getGlobalVendor() == EDbVendor.dbvmssql) {
                                                        this.schema = "dbo";
                                                } else {
                                                        this.schema = getDefaultSchema();
                                                }
                                        }
                                        else if (TSQLEnv.DEFAULT_SCHEMA_NAME.equalsIgnoreCase(this.schema)
                                                        && ModelBindingManager.getGlobalVendor() == EDbVendor.dbvmssql) {
                                                this.schema = "dbo";
                                        }
                                        builder.append(this.schema).append(".");
                                } else {
                                        if (!SQLUtil.isEmpty(this.schema) && !TSQLEnv.DEFAULT_SCHEMA_NAME.equalsIgnoreCase(this.schema)) {
                                                builder.append(this.schema).append(".");
                                        }
                                }
                        }
                        builder.append(this.name);
                        this.name = builder.toString();
                } else if (supportCatalog) {
                        if (segments.size() > 1) {
                                this.name = segments.get(segments.size() - 2) + "." + this.name;
                        }
                        else {
                                if (!SQLUtil.isEmpty(this.database) && !TSQLEnv.DEFAULT_DB_NAME.equalsIgnoreCase(this.database)) {
                                        this.name = this.database + "." + this.name;
                                }
                        }
                } else if (supportSchema) {
                        if (segments.size() > 1) {
                                this.name = segments.get(segments.size() - 2) + "." + this.name;
                        } else {
                                if (!SQLUtil.isEmpty(this.schema) && !TSQLEnv.DEFAULT_SCHEMA_NAME.equalsIgnoreCase(this.schema)) {
                                        this.name = this.schema + "." + this.name;
                                }
                        }
                }

                if (this.server != null && !this.server.equals(getDefaultServer())) {
                        this.name = this.server + "." + this.name;
                }
        }

        public long getId() {
                return id;
        }

        public String getName() {
                return name;
        }

        public void setName(String name) {
                EDbVendor vendor = ModelBindingManager.getGlobalOption().getVendor();
                boolean supportCatalog = TSQLEnv.supportCatalog(vendor);
                boolean supportSchema = TSQLEnv.supportSchema(vendor);
                if (!supportCatalog) {
                        this.database = null;
                } else if (this.database == null && !TSQLEnv.DEFAULT_DB_NAME.equals(getDefaultDatabase())) {
                        this.database = getDefaultDatabase();
                }

                if (!supportSchema) {
                        this.schema = null;
                } else if (this.schema == null && !TSQLEnv.DEFAULT_SCHEMA_NAME.equals(getDefaultSchema())) {
                        this.schema = getDefaultSchema();
                }
                
                this.name = name;
                
                updateTableName(supportCatalog, supportSchema);
        }

        public Pair3<Long, Long, String> getStartPosition() {
                return startPosition;
        }

        public Pair3<Long, Long, String> getEndPosition() {
                return endPosition;
        }

        public List<TableColumn> getColumns() {
                return columns;
        }

        public void addColumn(TableColumn column) {
                if (column != null && !this.columns.contains(column)) {
                        this.columns.add(column);
                }
        }

        public TTable getTableObject() {
                return tableObject;
        }

        public String getAlias() {
                String aliasString = Arrays.toString(this.alias.toArray(new String[0]));
                return aliasString.substring(1, aliasString.length() - 1);
        }

        public void setAlias(String alias) {
                if (!SQLUtil.isEmpty(alias)) {
                        this.alias.add(alias);
                }
        }

        public String getFullName() {
                return fullName;
        }


        public boolean hasSubquery() {
                return subquery;
        }

        public String getParent() {
                return parent;
        }

        public void setParent(String parent) {
                this.parent = parent;
        }

//      public TObjectName getTableName() {
//              return tableName;
//      }

        public String getDatabase() {
                return database;
        }

        public String getSchema() {
                return schema;
        }

        public TableRelationRows getRelationRows() {
                return relationRows;
        }

        public boolean isCreateTable() {
                return isCreateTable;
        }

        public void setCreateTable(boolean isCreateTable, boolean fromDDL) {
                Stack<TCustomSqlStatement> stmtStack = ModelBindingManager.getGlobalStmtStack();
                TCustomSqlStatement stmt = null;
                if (stmtStack != null && !stmtStack.isEmpty()) {
                        stmt = stmtStack.peek();
                }
                if (stmt != null && stmt.getClass().getSimpleName().startsWith("TCreate")) {
                        Pair<Pair3<Long, Long, String>, Pair3<Long, Long, String>> position = setPosition(stmt);
                        if (position != null) {
                                this.startPosition = position.first;
                                this.endPosition = position.second;
                        }
                }
                this.isCreateTable = isCreateTable;
                if (isCreateTable) {
                        for (TableColumn column : columns) {
                                column.setShowStar(false);
                        }
                        setDetermined(true);
                        if (fromDDL) {
                                setFromDDL(true);
                        }
                }
        }
        
        public void setCreateTable(boolean isCreateTable) {
                setCreateTable(isCreateTable, false);
        }

        public boolean isView() {
                return isView;
        }

        public void setView(boolean isView) {
                this.isView = isView;
        }

        public boolean isPseudo() {
                return isPseudo;
        }

        public void setPseudo(boolean isPseudo) {
                this.isPseudo = isPseudo;
        }

        public boolean isExternal() {
                return isExternal;
        }

        public void setExternal(boolean isExternal) {
                this.isExternal = isExternal;
        }

        public boolean isStage() {
                return isStage;
        }

        public void setStage(boolean isStage) {
                this.isStage = isStage;
        }

        public boolean isSequence() {
                return isSequence;
        }

        public void setSequence(boolean sequence) {
                isSequence = sequence;
        }

        public boolean isVariable() {
                return isVariable;
        }

        public void setVariable(boolean isVariable) {
                this.isVariable = isVariable;
        }

        public boolean isConstant() {
                return isConstant;
        }

        public void setConstant(boolean isConstant) {
                this.isConstant = isConstant;
        }

        public boolean isTarget() {
                return isTarget;
        }

        public void setTarget(boolean isTarget) {
                this.isTarget = isTarget;
        }

        public String getProcedureId() {
                return procedureId;
        }

        public void setProcedureId(String procedureId) {
                this.procedureId = procedureId;
        }

        public boolean isPath() {
                return isPath;
        }

        public void setPath(boolean isPath) {
                this.isPath = isPath;
                if(isPath) {
                        String filePathDatabase = ModelBindingManager.getGlobalOption().getFilePathDatabase();
                        String filePathSchema = ModelBindingManager.getGlobalOption().getFilePathSchema();
                        if(SQLUtil.isEmpty(filePathDatabase)) {
                                this.database = null;
                        }
                        else {
                                this.database = filePathDatabase;
                        }
                        if(SQLUtil.isEmpty(filePathSchema)) {
                                this.schema = null;
                        }
                        else {
                                this.schema = filePathSchema;
                        }

                        EDbVendor vendor = ModelBindingManager.getGlobalOption().getVendor();
                        boolean supportCatalog = TSQLEnv.supportCatalog(vendor);
                        boolean supportSchema = TSQLEnv.supportSchema(vendor);
                        if (!supportCatalog) {
                                this.database = null;
                        } else if (this.database == null && !TSQLEnv.DEFAULT_DB_NAME.equals(getDefaultDatabase())) {
                                this.database = getDefaultDatabase();
                        }

                        if (!supportSchema) {
                                this.schema = null;
                        } else if (this.schema == null && !TSQLEnv.DEFAULT_SCHEMA_NAME.equals(getDefaultSchema())) {
                                this.schema = getDefaultSchema();
                        }

                        updateTableName(supportCatalog, supportSchema);
                }
        }

        public boolean isCursor() {
                return isVariable && getSubType() == SubType.cursor;
        }

        public String getLocation() {
                return location;
        }

        public void setLocation(String location) {
                this.location = location;
        }

        public String getFileType() {
                return fileType;
        }

        public void setFileType(String fileType) {
                this.fileType = fileType;
        }

        public String getDisplayName() {
                return displayName;
        }

        public void setDisplayName(String displayName) {
                this.displayName = displayName;
        }

        public String getFileFormat() {
                return fileFormat;
        }

        public void setFileFormat(String fileFormat) {
                this.fileFormat = fileFormat;
        }

        public List<Process> getProcesses() {
                return processes;
        }

        public void addProcess(Process process) {
                if (processes == null) {
                        processes = new ArrayList<Process>();
                }
                if (process != null && !processes.contains(process)) {
                        processes.add(process);
                }
        }
        
        public void removeProcess(Process process) {
                if (processes == null) {
                        processes = new ArrayList<Process>();
                }
                if (process != null && processes.contains(process)) {
                        processes.remove(process);
                }
        }

        public void setSubType(SubType subType) {
                if (this.subType == null || subType == SubType.record_type) {
                        this.subType = subType;
                }
        }

        public SubType getSubType() {
                return subType;
        }

        public boolean isStream() {
                return isStream;
        }

        public void setStream(boolean isStream) {
                this.isStream = isStream;
        }

        public boolean isSchema() {
                return isSchema;
        }

        public void setSchema(boolean isSchema) {
                this.isSchema = isSchema;
        }

        public void setDatabase(String database) {
                this.database = database;
        }

        public boolean isDatabase() {
                return isDatabase;
        }

        public void setDatabase(boolean isDatabase) {
                this.isDatabase = isDatabase;
        }

        public boolean isDataSource() {
                return isDataSource;
        }

        public void setDataSource(boolean dataSource) {
                isDataSource = dataSource;
        }

        public String getStarStmt() {
                return starStmt;
        }

        public void setStarStmt(String starStmt) {
                this.starStmt = starStmt;
        }

        public void setHasSQLEnv(boolean hasSQLEnv) {
                this.hasSQLEnv = hasSQLEnv;
        }

        public boolean hasSQLEnv() {
                return hasSQLEnv;
        }

        public String getCurrentAlias() {
                return currentAlias;
        }

        public void setCurrentAlias(String currentAlias) {
                if (SQLUtil.isEmpty(currentAlias)) {
                        this.currentAlias = null;
                } else
                        this.currentAlias = currentAlias;
        }

        public Set<String> getAliasList() {
                return alias;
        }

        public String getServer() {
                return server;
        }

        public boolean isDetermined() {
                return isDetermined;
        }

        public void setDetermined(boolean isDetermined) {
                this.isDetermined = isDetermined;
        }

        public boolean isFromDDL() {
                return fromDDL;
        }

        public void setFromDDL(boolean fromDDL) {
                this.fromDDL = fromDDL;
        }

        /**
         * Whether this endpoint is created by the analyzed SQL. A parse fact, NOT gated on
         * {@link #isDetermined()}; true for CREATE TABLE / SELECT INTO / CTAS / clone
         * targets even when the defining query's schema could not be resolved.
         */
        public boolean isCreatedInSql() {
                return createdInSql;
        }

        public void setCreatedInSql(boolean createdInSql) {
                this.createdInSql = createdInSql;
        }

        public EndpointIntroduction getEndpointIntroduction() {
                return endpointIntroduction;
        }

        /**
         * Records how the endpoint was introduced. First non-UNKNOWN writer wins, so the
         * structural creation site (set early at build time) is not later clobbered.
         */
        public void setEndpointIntroduction(EndpointIntroduction endpointIntroduction) {
                if (endpointIntroduction == null) {
                        return;
                }
                if (this.endpointIntroduction == null || this.endpointIntroduction == EndpointIntroduction.UNKNOWN) {
                        this.endpointIntroduction = endpointIntroduction;
                }
        }

        /**
         * Existing schema/model resolution state, exposed under the endpoint-classification
         * name. Mirrors {@link #isDetermined()} exactly; introduces no new resolution logic.
         */
        public boolean isResolved() {
                return isDetermined;
        }

        /**
         * Delimiter-normalized, dialect-aware form of {@link #getName()} (brackets / quotes
         * stripped per identifier segment). Computed on access from the current name; does
         * NOT mutate {@link #getName()}, which stays raw. Returns the raw name when no
         * normalization is possible (e.g. no global vendor context).
         */
        public String getNormalizedName() {
                if (name == null) {
                        return null;
                }
                try {
                        String normalized = DlineageUtil.getIdentifierNormalTableName(name);
                        return normalized == null ? name : normalized;
                } catch (Exception e) {
                        return name;
                }
        }

        /**
         * Records that this endpoint's identifier was assembled at runtime by a dynamic-SQL
         * fold. {@code parts} is the outermost-first, pipe-joined set of affected name
         * segments; {@code identityTemplated} says the hole reaches the leading character of
         * the object-name segment (so a {@code #}/{@code @} prefix there is fold text, not a
         * real temp / table-variable marker). Additive across repeated marks: parts union,
         * identity ORs — one folded statement can reach the same endpoint twice.
         *
         * <p>Callers MUST only invoke this from inside a dynamic-fold context; see
         * {@link EndpointKind#DYNAMIC_TEMPLATE}.
         */
        public void markDynamicTemplate(String parts, boolean identityTemplated) {
                if (parts != null && parts.length() > 0) {
                        if (this.templatedParts == null) {
                                this.templatedParts = parts;
                        } else if (!this.templatedParts.equals(parts)) {
                                java.util.LinkedHashSet<String> merged = new java.util.LinkedHashSet<String>();
                                for (String part : TEMPLATED_PART_ORDER) {
                                        if (containsPart(this.templatedParts, part) || containsPart(parts, part)) {
                                                merged.add(part);
                                        }
                                }
                                StringBuilder sb = new StringBuilder();
                                for (String part : merged) {
                                        if (sb.length() > 0) {
                                                sb.append('|');
                                        }
                                        sb.append(part);
                                }
                                this.templatedParts = sb.toString();
                        }
                }
                this.templatedIdentity = this.templatedIdentity || identityTemplated;
        }

        /** Canonical outermost-first ordering of the segment labels used by {@link #getTemplatedParts()}. */
        private static final String[] TEMPLATED_PART_ORDER = { "server", "db", "schema", "name" };

        private static boolean containsPart(String parts, String part) {
                if (parts == null) {
                        return false;
                }
                for (String candidate : parts.split("\\|")) {
                        // non-identifier-compare: fixed internal label vocabulary, not a DB object name
                        if (candidate.equals(part)) {
                                return true;
                        }
                }
                return false;
        }

        /**
         * Which identifier segments of {@link #getName()} were assembled at runtime, pipe-joined
         * outermost-first ({@code "db"}, {@code "db|name"}, ...); {@code null} when this endpoint
         * is not runtime-templated. Lets a consumer match a templated skeleton against a
         * later-resolved concrete name without re-parsing the name text.
         */
        public String getTemplatedParts() {
                return templatedParts;
        }

        /** True when this endpoint's identifier was assembled at runtime by a dynamic-SQL fold. */
        public boolean isDynamicTemplate() {
                return templatedParts != null;
        }

        /**
         * Withdraws a dynamic-template mark. Used when the SAME node turns out to also be
         * referenced by a STATIC statement (by-name model reuse): the static reference provably
         * names a real object, so publishing the template claim on the shared node would make
         * that reference wrong — see the shared-node contract in
         * docs/tmp/dynamic-template-endpoint-provenance.md.
         */
        public void clearDynamicTemplate() {
                this.templatedParts = null;
                this.templatedIdentity = false;
        }

        /**
         * Authoritative {@link EndpointKind}, computed on access from the current (raw)
         * name and the active dialect. Quote-robust: each identifier segment is delimiter-
         * stripped before the {@code #}/{@code ##}/{@code @}/{@code tempdb} tests. This
         * reads only the new classification; it never inspects or mutates {@link #subType}.
         *
         * <p>§5.6 minimum scope: distinguishes T-SQL temp / global-temp / table-variable /
         * tempdb objects from plain catalog objects. CTE / derived / TVF / constant kinds
         * are deferred and reported as {@link EndpointKind#UNKNOWN} here.
         */
        public static boolean isTsqlFamilyVendor(EDbVendor vendor) {
                return vendor == EDbVendor.dbvmssql || vendor == EDbVendor.dbvazuresql
                                || vendor == EDbVendor.dbvsybase || vendor == EDbVendor.dbvsybasease
                                || vendor == EDbVendor.dbvsqlanywhere || vendor == EDbVendor.dbvsybaseiq;
        }

        public EndpointKind getEndpointKind() {
                if (SQLUtil.isEmpty(name)) {
                        return EndpointKind.UNKNOWN;
                }

                EDbVendor vendor = null;
                if (ModelBindingManager.getGlobalOption() != null) {
                        vendor = ModelBindingManager.getGlobalOption().getVendor();
                }

                if (isTsqlFamilyVendor(vendor)) {
                        List<String> segments = SQLUtil.parseNames(name);
                        if (!segments.isEmpty()) {
                                String last = SQLUtil.trimColumnStringQuote(segments.get(segments.size() - 1).trim());
                                // A '#'/'##'/'@' prefix that came out of a dynamic fold hole is runtime text,
                                // not evidence of a temp table / table variable: 'INSERT INTO ' + QUOTENAME(@tab)
                                // folds to a table literally named @tab, which is a runtime-built CATALOG name.
                                // Only then does DYNAMIC_TEMPLATE displace the temp family; a genuinely literal
                                // '#tmp_' prefix keeps its temp kind (the templated segments stay readable via
                                // getTemplatedParts()), because losing TEMP would send a consumer to the catalog.
                                if (last.startsWith("##")) {
                                        return templatedIdentity ? EndpointKind.DYNAMIC_TEMPLATE : EndpointKind.GLOBAL_TEMP_TABLE;
                                }
                                if (last.startsWith("#")) {
                                        return templatedIdentity ? EndpointKind.DYNAMIC_TEMPLATE : EndpointKind.LOCAL_TEMP_TABLE;
                                }
                                if (last.startsWith("@")) {
                                        return templatedIdentity ? EndpointKind.DYNAMIC_TEMPLATE : EndpointKind.TABLE_VARIABLE;
                                }
                                String first = SQLUtil.trimColumnStringQuote(segments.get(0).trim());
                                if (segments.size() > 1 && "tempdb".equalsIgnoreCase(first)) {
                                        // A literal leading "tempdb" proves the object lives in tempdb whatever the
                                        // later segments template to, so the kind stands and templatedParts carries
                                        // the rest of the story.
                                        return EndpointKind.TEMPDB_OBJECT;
                                }
                        }
                }

                // A runtime-assembled identifier is never a catalog object name: report the
                // template, so a consumer does not bind it (or, worse, match an unrelated object
                // that happens to share the folded spelling). Marked only inside a fold context.
                if (templatedParts != null) {
                        return EndpointKind.DYNAMIC_TEMPLATE;
                }

                // Only a plain real table is a catalog object here. Resultsets / derived /
                // views / variables / stages etc. are deferred kinds — leave them UNKNOWN
                // rather than mislabel them CATALOG_OBJECT.
                if (!subquery && !isView && !isPseudo && !isStage && !isSequence && !isStream
                                && !isVariable && !isConstant && !isDatabase && !isSchema && !isDataSource
                                && subType != SubType.alias_table && subType != SubType.values_table
                                && subType != SubType.synonym && subType != SubType.function
                                && subType != SubType.unnest) {
                        return EndpointKind.CATALOG_OBJECT;
                }

                return EndpointKind.UNKNOWN;
        }

        private Pair<Pair3<Long, Long, String>, Pair3<Long, Long, String>> setPositionInternal(TSourceToken startToken, TSourceToken endToken) {
                if (startToken == null || endToken == null) {
                        return null;
                }

                Pair3<Long, Long, String> startPosition = new Pair3<Long, Long, String>(startToken.lineNo, startToken.columnNo,
                                ModelBindingManager.getGlobalHash());
                Pair3<Long, Long, String> endPosition = new Pair3<Long, Long, String>(endToken.lineNo, endToken.columnNo + SQLUtil.endTrim(endToken.getAstext()).length(),
                                ModelBindingManager.getGlobalHash());

                if(this.startPosition == null && this.endPosition == null) {
                        this.startPosition = startPosition;
                        this.endPosition = endPosition;
                }

                boolean traceTablePosition = ModelBindingManager.getGlobalOption().isTraceTablePosition();

                
                Pair<Pair3<Long, Long, String>, Pair3<Long, Long, String>> position = Pair.create(startPosition, endPosition);
                
                if (traceTablePosition) {
                        positions.add(position);
                }
                
                return position;
        }

        public Pair<Pair3<Long, Long, String>, Pair3<Long, Long, String>> setPosition(TTable table) {
                if (table == null) {
                        return null;
                }
                
                TSourceToken startToken = table.getStartToken();
                TSourceToken endToken = table.getEndToken();
                if (startToken == null && table.getSubquery() != null) {
                        startToken = table.getSubquery().getStartToken();
                        endToken = table.getSubquery().getEndToken();
                }

                return setPositionInternal(startToken, endToken);
        }

        public Pair<Pair3<Long, Long, String>, Pair3<Long, Long, String>> setPosition(TObjectName tableName) {
                if (tableName == null) {
                        return null;
                }
                
                TSourceToken startToken = tableName.getStartToken();
                TSourceToken endToken = tableName.getEndToken();
                
                return setPositionInternal(startToken, endToken);
        }

        public Pair<Pair3<Long, Long, String>, Pair3<Long, Long, String>> setPosition(TCustomSqlStatement stmt) {
                if (stmt == null) {
                        return null;
                }
                
                TSourceToken startToken = stmt.getStartToken();
                TSourceToken endToken = stmt.getEndToken();
                
                return setPositionInternal(startToken, endToken);
        }

        public Set<Pair<Pair3<Long, Long, String>, Pair3<Long, Long, String>>> getPositions() {
                return positions;
        }
        
        public TableColumn findColumn(String columnName) {
                if (columns == null) {
                        return null;
                }
                for (TableColumn column : columns) {
                        if (DlineageUtil.compareColumnIdentifier(column.getName(), columnName)) {
                                return column;
                        }
                }
                return null;
        }

        public void removeColumn(TableColumn column) {
                if (columns != null && columns.contains(column)) {
                        columns.remove(column);
                }
        }

        public void removeColumn(String columnName) {
                TableColumn column = findColumn(columnName);
                if (column != null) {
                        removeColumn(column);
                }
        }
}