package gudusoft.gsqlparser.dlineage.dataflow.model;

import gudusoft.gsqlparser.EDbVendor;
import gudusoft.gsqlparser.ETableEffectType;
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.LegacyDlineageWireNamesV1;
import gudusoft.gsqlparser.dlineage.util.TableIdentityKey;
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;
        // Captured in the occurrence's context, before rendering/quote removal.
        private QualifiedCanonKey identifierKey;

        public QualifiedCanonKey getIdentifierKey() {
                return identifierKey;
        }

        private void captureIdentifierKey(String lexicalName, TSQLTable resolved) {
                if (ModelBindingManager.getGlobalVendor() != EDbVendor.dbvbigquery) return;
                identifierKey = resolved == null || !inSpelledProject(lexicalName, resolved)
                                ? (QualifiedCanonKey) DlineageUtil.getTableIdentityKey(lexicalName)
                                : IdentifierService.qualifiedCanonKeyFromStoredStatic(EDbVendor.dbvbigquery,
                                                ESQLDataObjectType.dotTable, Arrays.asList(resolved.getSchema().getCatalog().getName(),
                                                                resolved.getSchema().getName(), resolved.getName()));
        }

        /**
         * Whether the catalog's table is in the project the name spells, when it spells one. The catalog lends a
         * reference that names a project the columns of a table declared without one (Mantis 4751), not that table's
         * identity: {@code db1.s1.t1} and {@code db2.s1.t1} stay two tables beside the declared {@code s1.t1}.
         */
        private static boolean inSpelledProject(String lexicalName, TSQLTable resolved) {
                List<String> segments = QualifiedNameHierarchy.split(EDbVendor.dbvbigquery, lexicalName);
                if (segments.size() < 3) return true;
                IdentifierService service = ModelBindingManager.getGlobalIdentifierService();
                if (service == null) service = IdentifierService.defaultServiceFor(EDbVendor.dbvbigquery);
                return service.canonKeyOf(segments.get(0), ESQLDataObjectType.dotCatalog, IdentifierInputForm.SQL_LEXICAL)
                                .equals(service.canonKeyOf(resolved.getSchema().getCatalog().getName(), ESQLDataObjectType.dotCatalog,
                                                IdentifierInputForm.CATALOG_STORED));
        }

        /**
         * Binding identity, separate from legacy display getters: the table's identity under the
         * analysis's identifier rules ({@link #getCanonicalIdentity()}) with the legacy folded name bound
         * alongside, or the legacy name alone for a table the rules give no identity.
         */
        public Object getBindingKey() {
                if (ModelBindingManager.getGlobalVendor() == EDbVendor.dbvbigquery) {
                        return getIdentifierKey();
                }
                String legacyKey = DlineageUtil.getTableFullName(getName());
                QualifiedCanonKey identity = getCanonicalIdentity();
                return identity == null ? legacyKey : new TableIdentityKey(identity, legacyKey);
        }

        /**
         * The form each level of the name that the reference did not spell arrived in, recorded where
         * the level is produced. Null is a SQL spelling: a session default, a {@code USE}, a resolver's
         * stamp, a file-path option. {@code CATALOG_STORED} is a name the catalog holds: the schema a
         * catalog search found an unqualified name in ({@link TObjectName#getImplictSchemaForm()}), or a
         * catalog or synonym match in {@link #fillSchemaInfo()}. The identity is minted from these, never
         * by re-reading the display name, which shows a stored name bare.
         */
        private IdentifierInputForm databaseForm;
        private IdentifierInputForm schemaForm;
        /** How many trailing segments of the composed name the reference itself spelled; -1 until composed. */
        private int spelledSegments = -1;
        /** The identity last minted, and the name it was minted for. */
        private QualifiedCanonKey mintedIdentity;
        private String mintedFor;

        private void assignDatabase(String database, IdentifierInputForm form) {
                this.database = database;
                // The global default is handed over as the very object ModelBindingManager holds (by
                // DlineageUtil.getTableDatabase, or through the session default the bootstrap set from it),
                // and a stored one keeps its form: a reference check, provenance rather than name equality.
                if (database != null && form == null && database == ModelBindingManager.getGlobalDatabase()) {
                        form = ModelBindingManager.getGlobalDatabaseForm();
                }
                this.databaseForm = database == null ? null : form;
        }

        private void assignSchema(String schema, IdentifierInputForm form) {
                this.schema = schema;
                if (schema != null && form == null && schema == ModelBindingManager.getGlobalSchema()) {
                        form = ModelBindingManager.getGlobalSchemaForm();
                }
                this.schemaForm = schema == null ? null : form;
        }

        private static IdentifierInputForm implicitSchemaForm(TObjectName name) {
                return name != null && name.getImplictSchemaForm() == IdentifierInputForm.CATALOG_STORED
                                ? IdentifierInputForm.CATALOG_STORED : null;
        }

        private static IdentifierInputForm implicitDatabaseForm(TObjectName name) {
                return name != null && name.getImplictDatabaseForm() == IdentifierInputForm.CATALOG_STORED
                                ? IdentifierInputForm.CATALOG_STORED : null;
        }

        /**
         * A catalog's stored name as it appears in the composed name: stored, unless the caller already
         * delimited it ({@code SQLUtil.quoteDottedName} for a stored name with a dot), which makes it the SQL
         * spelling of that name.
         */
        private static IdentifierInputForm storedUnlessDelimited(ESQLDataObjectType role, String name) {
                if (name == null) {
                        return null;
                }
                IdentifierService service = ModelBindingManager.getGlobalIdentifierService();
                IdentifierProfile profile = service != null ? service.getProfile()
                                : IdentifierProfile.forVendor(ModelBindingManager.getGlobalVendor(), IdentifierProfile.VendorFlags.defaults());
                return IdentifierCodec.isQuoted(profile, role, name) ? null : IdentifierInputForm.CATALOG_STORED;
        }

        /**
         * The table's identity under the analysis's identifier rules: BigQuery's captured key, else a key
         * minted from the composed name's segments, each read in the form it arrived in. Levels the
         * reference spelled, and levels a SQL spelling supplied, are read as SQL; a level the catalog
         * supplied is read as the stored name it is. Minted during analysis and kept until the name
         * changes, so the output merge sees the identity the model was bound under. Null for a name the
         * rules give no identity: a database link, a shape the vendor's hierarchy cannot split, or a
         * segment that is not an identifier.
         */
        public QualifiedCanonKey getCanonicalIdentity() {
                if (identifierKey != null) {
                        return identifierKey;
                }
                if (name == null) {
                        return null;
                }
                if (mintedFor != name) { // reference check: re-mint only when the name itself changed
                        mintedIdentity = mintIdentity();
                        mintedFor = name;
                }
                return mintedIdentity;
        }

        /**
         * The table's identity read in another object role of the same level ({@code dotSynonyms} for a name that may
         * name a synonym): the same segments, forms and rules as {@link #getCanonicalIdentity()}, the last segment under
         * that role's rules. A per-object profile may give synonyms rules of their own, so a synonym is matched in its
         * own role. Null when the rules give the name no identity.
         */
        public QualifiedCanonKey getCanonicalIdentityAs(ESQLDataObjectType role) {
                if (role == null || role == ESQLDataObjectType.dotTable) {
                        return getCanonicalIdentity();
                }
                return name == null ? null : mintIdentity(role);
        }

        private QualifiedCanonKey mintIdentity() {
                return mintIdentity(ESQLDataObjectType.dotTable);
        }

        private QualifiedCanonKey mintIdentity(ESQLDataObjectType role) {
                IdentifierService service = ModelBindingManager.getGlobalIdentifierService();
                if (service == null || subType == SubType.dblink
                                || (ModelBindingManager.get() != null && ModelBindingManager.get().isDblinkTable(name))) {
                        return null;
                }
                IdentifierProfile profile = service.getProfile();
                EDbVendor vendor = profile.getVendor();
                if (!QualifiedNameHierarchy.hasHierarchyMapping(vendor, role)) {
                        return null;
                }
                List<QualifiedNameHierarchy.Segment> plan = QualifiedNameHierarchy.plan(vendor, role,
                                QualifiedNameHierarchy.split(vendor, DlineageUtil.getTableFullNameAsWritten(name)));
                if (plan == null) {
                        return null;
                }
                int spelled = spelledSegments < 0 ? plan.size() : Math.min(spelledSegments, plan.size());
                List<String> texts = new ArrayList<String>(plan.size());
                List<IdentifierInputForm> forms = new ArrayList<IdentifierInputForm>(plan.size());
                for (int i = 0; i < plan.size(); i++) {
                        QualifiedNameHierarchy.Segment segment = plan.get(i);
                        IdentifierInputForm form = IdentifierInputForm.SQL_LEXICAL;
                        if (i < plan.size() - spelled && !IdentifierCodec.isQuoted(profile, segment.getType(), segment.getText())) {
                                IdentifierInputForm produced = segment.getType() == ESQLDataObjectType.dotSchema ? schemaForm
                                                : segment.getType() == ESQLDataObjectType.dotCatalog ? databaseForm : null;
                                if (produced == IdentifierInputForm.CATALOG_STORED) {
                                        form = IdentifierInputForm.CATALOG_STORED;
                                }
                        }
                        if (form == IdentifierInputForm.SQL_LEXICAL
                                        && !IdentifierCodec.isVendorValidSpelling(profile, segment.getType(), segment.getText())) {
                                return null;
                        }
                        texts.add(segment.getText());
                        forms.add(form);
                }
                try {
                        return service.qualifiedCanonKeyFromSegments(texts, forms, role);
                } catch (RuntimeException noIdentity) {
                        return null;
                }
        }
        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 dataSourceName;
        private String pathUri;
        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());
                
                captureIdentifierKey(tableName, null);

                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());
                        assignDatabase(DlineageUtil.getTableDatabase(table.getTableName().toString()), null);
                        assignSchema(DlineageUtil.getTableSchema(table.getTableName().toString()), null);
                }
                else {
                        if (this.server == null && !TSQLEnv.DEFAULT_SERVER_NAME.equals(getDefaultServer())) {
                                this.server = getDefaultServer();
                        }
                        assignDatabase(LegacyDlineageWireNamesV1.segment(vendor, ESQLDataObjectType.dotDblink, table.getTableName().getDblink().toString()), null);
                        if (!SQLUtil.isEmpty(table.getTableName().getSchemaString())) {
                                assignSchema(table.getTableName().getSchemaString(), null);
                        }
                        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)) {
                        assignDatabase(DlineageUtil.getTableDatabase(table.getTableName().toString()), null);
                        if (SQLUtil.isEmpty(this.database) && ModelBindingManager.getGlobalOption().isShowImplicitSchema()
                                        && !SQLUtil.isEmpty(table.getTableName().getImplictDatabaseString())) {
                                assignDatabase(table.getTableName().getImplictDatabaseString(), implicitDatabaseForm(table.getTableName()));
                        }
                }

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

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

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

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

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

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

                captureIdentifierKey(table.getLinkTable() == null ? this.name
                                : table.getLinkTable().getTableName().toString(), table.getResolvedTable());

                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());
                        assignDatabase(DlineageUtil.getTableDatabase(table.getTableName().toString()), null);
                        assignSchema(DlineageUtil.getTableSchema(table.getTableName().toString()), null);
                }
                else {
                        if (this.server == null && !TSQLEnv.DEFAULT_SERVER_NAME.equals(getDefaultServer())) {
                                this.server = getDefaultServer();
                        }
                        assignDatabase(LegacyDlineageWireNamesV1.segment(vendor, ESQLDataObjectType.dotDblink, table.getTableName().getDblink().toString()), null);
                        if (!SQLUtil.isEmpty(table.getTableName().getSchemaString())) {
                                assignSchema(table.getTableName().getSchemaString(), null);
                        }
                        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)) {
                        assignDatabase(DlineageUtil.getTableDatabase(table.getTableName().toString()), null);
                        if (SQLUtil.isEmpty(this.database) && ModelBindingManager.getGlobalOption().isShowImplicitSchema()
                                        && !SQLUtil.isEmpty(table.getTableName().getImplictDatabaseString())) {
                                assignDatabase(table.getTableName().getImplictDatabaseString(), implicitDatabaseForm(table.getTableName()));
                        }
                }

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

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

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

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

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

                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;
                                if (tsqlColumn.isUnresolvedStar()) {
                                        columnName = DlineageUtil.syntheticStarName();
                                } else {
                                        columnName = DeclaredColumnName.ofCatalog(tsqlColumn.getName(),
                                                        TSQLEnv.toLexical(ModelBindingManager.getGlobalVendor(),
                                                                        ESQLDataObjectType.dotColumn, tsqlColumn.getName(),
                                                                        gudusoft.gsqlparser.sqlenv.IdentifierInputForm.CATALOG_STORED));
                                }
                                TableColumn column = new TableColumn(this, columnName);
                                column.name = tsqlColumn.getName();
                        }
                        this.setCreateTable(true);
                        this.setHasSQLEnv(true);
                }
        }

        private TSQLEnv metadataEnvironment() {
                if (tableObject != null && tableObject.getSqlEnv() != null && ModelBindingManager.isScopedTemporary(tableObject)) {
                        // SELECT INTO introduces this spelling; its inferred shape does not qualify the name.
                        if (tableObject.getEffectType() == ETableEffectType.tetSelectInto) return null;
                        return tableObject.getSqlEnv();
                }
                return ModelBindingManager.getGlobalSQLEnv();
        }

        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")) {
                                                assignDatabase(properties.getProperty("db"), null);
                                                if(this.database.indexOf(".")!=-1) {
                                                        assignDatabase(SQLUtil.quoteDottedName(ModelBindingManager.getGlobalOption().getVendor(), ESQLDataObjectType.dotCatalog, this.database), null);
                                                }
                                        }
                                        if (SQLUtil.isEmpty(this.schema) && properties.containsKey("schema")) {
                                                assignSchema(properties.getProperty("schema"), null);
                                                if(this.schema.indexOf(".")!=-1) {
                                                        assignSchema(SQLUtil.quoteDottedName(ModelBindingManager.getGlobalOption().getVendor(), ESQLDataObjectType.dotSchema, this.schema), null);
                                                }
                                        }
                                } 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 = metadataEnvironment();
                        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, schema.getNameKeepCase() });
                                                        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)) {
                                        assignDatabase(tableDatabase, storedUnlessDelimited(ESQLDataObjectType.dotCatalog, tableDatabase));
                                }
                                if (this.schema == null && tableSchema != null && !TSQLEnv.DEFAULT_SCHEMA_NAME.equalsIgnoreCase(tableSchema)) {
                                        assignSchema(tableSchema, storedUnlessDelimited(ESQLDataObjectType.dotSchema, 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[3], 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 = metadataEnvironment();
                        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)) {
                                        assignDatabase(tableDatabase, storedUnlessDelimited(ESQLDataObjectType.dotCatalog, tableDatabase));
                                }
                                if (this.schema == null && tableSchema != null && !TSQLEnv.DEFAULT_SCHEMA_NAME.equalsIgnoreCase(tableSchema)) {
                                        assignSchema(tableSchema, storedUnlessDelimited(ESQLDataObjectType.dotSchema, tableSchema));
                                }
                        }

                        if (SQLUtil.isEmpty(this.schema) && !SQLUtil.isEmpty(this.database)) {
                                assignSchema(getDefaultSchema(), null);
                        }
                }
        }

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

                captureIdentifierKey(tableName.toString(), null);

                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());
                assignDatabase(DlineageUtil.getTableDatabase(tableName.toString()), null);
                assignSchema(DlineageUtil.getTableSchema(tableName.toString()), null);

                fillSchemaInfo();

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

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

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

                if (supportSchema && !SQLUtil.isEmpty(this.database) && SQLUtil.isEmpty(this.schema)) {
                        if (!SQLUtil.isEmpty(implicitSchemaOf(tableName))) {
                                assignSchema(implicitSchemaOf(tableName), implicitSchemaForm(tableName));
                        } else {
                                assignSchema(getDefaultSchema(), null);
                        }
                }

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

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

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

        /** Drops the model's position: a table no SQL named has none to publish. */
        void dropPosition() {
                startPosition = null;
                endPosition = null;
                positions.clear();
        }

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

                captureIdentifierKey(tableName, null);

                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)) {
                        assignDatabase(DlineageUtil.getTableDatabase(tableName), null);
                }
                if (supportSchema && SQLUtil.isEmpty(this.schema)) {
                        assignSchema(DlineageUtil.getTableSchema(tableName), null);
                }
                if (supportSchema && !SQLUtil.isEmpty(this.database) && SQLUtil.isEmpty(this.schema)) {
                        assignSchema(getDefaultSchema(), null);
                }

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

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

                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);
                spelledSegments = segments.size();
                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) {
                                                        assignSchema("dbo", null);
                                                } else {
                                                        assignSchema(getDefaultSchema(), null);
                                                }
                                        }
                                        else if (TSQLEnv.DEFAULT_SCHEMA_NAME.equalsIgnoreCase(this.schema)
                                                        && ModelBindingManager.getGlobalVendor() == EDbVendor.dbvmssql) {
                                                assignSchema("dbo", null);
                                        }
                                        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) {
                        assignDatabase(null, null);
                } else if (this.database == null && !TSQLEnv.DEFAULT_DB_NAME.equals(getDefaultDatabase())) {
                        assignDatabase(getDefaultDatabase(), null);
                }

                if (!supportSchema) {
                        assignSchema(null, null);
                } else if (this.schema == null && !TSQLEnv.DEFAULT_SCHEMA_NAME.equals(getDefaultSchema())) {
                        assignSchema(getDefaultSchema(), null);
                }
                
                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);
                }
        }

        /**
         * STRUCT tree: the field path nodes below this table's columns ({@code customer.address},
         * {@code customer.address.city}, {@code items[*]}), in the order they were made. They are not columns of their own,
         * so they are kept out of {@link #getColumns()}, which star expansion and positional writes walk; the output lists
         * them with their columns ({@link #getColumnsWithFieldPaths()}).
         */
        private List<TableColumn> fieldPathColumns = new ArrayList<TableColumn>();

        /** The field path nodes, read-only: they are added by the field-path constructor only, which keeps the index. */
        public List<TableColumn> getFieldPathColumns() {
                return java.util.Collections.unmodifiableList(fieldPathColumns);
        }

        /** The field path nodes by their structural identity ({@link FieldNodeKey}), in the order they were made. */
        private final java.util.Map<FieldNodeKey, TableColumn> fieldPathIndex =
                        new java.util.LinkedHashMap<FieldNodeKey, TableColumn>();

        /** Makes {@code column}, a field path node, one of {@link #getFieldPathColumns()} rather than a column. */
        void addFieldPathColumn(TableColumn column) {
                columns.remove(column);
                if (!fieldPathColumns.contains(column)) {
                        fieldPathColumns.add(column);
                        FieldNodeKey key = FieldNodeKey.of(column);
                        if (!fieldPathIndex.containsKey(key)) {
                                fieldPathIndex.put(key, column);
                        }
                }
        }

        /** Whether this is the relation a table-generating construct (a LATERAL VIEW) adds to one SELECT. */
        private boolean arrayRelation;

        public boolean isArrayRelation() {
                return arrayRelation;
        }

        public void setArrayRelation(boolean arrayRelation) {
                this.arrayRelation = arrayRelation;
        }

        /** The field path node with identity {@code key}, or null. */
        public TableColumn getFieldPathNode(FieldNodeKey key) {
                return fieldPathIndex.get(key);
        }

        /** Plan rule R10: the nested-field declarations of this table, one per CREATE TABLE, in the order made. */
        private final List<FieldDeclaration> fieldDeclarations = new ArrayList<FieldDeclaration>(0);

        /** The declaration of the CREATE TABLE being analyzed; null between statements. */
        private FieldDeclaration buildingFieldDeclaration;

        /**
         * Starts the declaration of the CREATE TABLE statement {@code created}, which the DROP TABLE {@code dropped}
         * ends ({@link FieldDeclaration#NEVER_DROPPED} when none does). Until {@link #endFieldDeclaration()}, the
         * declared fields recorded are this declaration's.
         */
        public FieldDeclaration openFieldDeclaration(long created, long dropped) {
                FieldDeclaration declaration = new FieldDeclaration(created, dropped);
                fieldDeclarations.add(declaration);
                buildingFieldDeclaration = declaration;
                return declaration;
        }

        /** Ends the declaration {@link #openFieldDeclaration} started. */
        public void endFieldDeclaration() {
                buildingFieldDeclaration = null;
        }

        /** The declaration declared fields are recorded in: the one being built, else the active one, else a new one. */
        FieldDeclaration fieldDeclarationForWrite() {
                if (buildingFieldDeclaration != null) {
                        return buildingFieldDeclaration;
                }
                FieldDeclaration active = getActiveFieldDeclaration();
                if (active != null) {
                        return active;
                }
                FieldDeclaration declaration = new FieldDeclaration(currentStatementOrdinal(), FieldDeclaration.NEVER_DROPPED);
                fieldDeclarations.add(declaration);
                return declaration;
        }

        /** The declaration a read of the statement being analyzed is validated against; null when there is none. */
        public FieldDeclaration getActiveFieldDeclaration() {
                if (buildingFieldDeclaration != null) {
                        return buildingFieldDeclaration;
                }
                return activeFieldDeclaration(currentStatementOrdinal());
        }

        private static long currentStatementOrdinal() {
                ModelBindingManager manager = ModelBindingManager.get();
                return manager == null ? -1 : manager.getCurrentStatementOrdinal();
        }

        /**
         * The declaration in force at the statement {@code at}: the latest one made before it that no DROP ended before
         * it. A statement before every CREATE of the table (a script that reads a table before its DDL) and a statement
         * after a DROP that no CREATE followed yet use the next declaration; an unknown position uses the latest.
         */
        FieldDeclaration activeFieldDeclaration(long at) {
                if (fieldDeclarations.isEmpty()) {
                        return null;
                }
                if (at < 0) {
                        return fieldDeclarations.get(fieldDeclarations.size() - 1);
                }
                FieldDeclaration inForce = null;
                FieldDeclaration next = null;
                for (FieldDeclaration declaration : fieldDeclarations) {
                        if (declaration.getCreated() <= at) {
                                if (at < declaration.getDropped()
                                                && (inForce == null || declaration.getCreated() >= inForce.getCreated())) {
                                        inForce = declaration;
                                }
                        } else if (next == null || declaration.getCreated() < next.getCreated()) {
                                next = declaration;
                        }
                }
                if (inForce != null) {
                        return inForce;
                }
                return next != null ? next : fieldDeclarations.get(fieldDeclarations.size() - 1);
        }

        /** The columns as the output lists them: each column followed by the field path nodes below it. */
        public List<TableColumn> getColumnsWithFieldPaths() {
                if (fieldPathColumns.isEmpty() && loadColumn == null) {
                        return columns;
                }
                List<TableColumn> published = new ArrayList<TableColumn>(columns.size() + fieldPathColumns.size() + 1);
                for (TableColumn column : columns) {
                        published.add(column);
                        for (TableColumn node : fieldPathColumns) {
                                if (node.getDeclaredColumn() == column) {
                                        published.add(node);
                                }
                        }
                }
                for (TableColumn node : fieldPathColumns) {
                        if (!published.contains(node)) {
                                published.add(node);
                        }
                }
                if (loadColumn != null) {
                        published.add(loadColumn);
                }
                return published;
        }

        /**
         * The {@code *} a bulk load (SQL Server BULK INSERT, Mantis 4962) feeds the table through as a whole, or null.
         * Like a field path node it is no column of the table: it is kept out of {@link #getColumns()}, which star
         * expansion, positional writes and column lookups walk, so a load changes no other statement's lineage and no
         * other statement's star, expansion or pruning reaches the load; the output lists it after the columns.
         */
        private TableColumn loadColumn;

        public TableColumn getLoadColumn() {
                return loadColumn;
        }

        /** Makes {@code column} the table's load column rather than one of its columns. */
        public void setLoadColumn(TableColumn column) {
                columns.remove(column);
                this.loadColumn = 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) {
                setPath(isPath, true);
        }

        /**
         * Marks a file path. With {@code defaultQualifiers} false the analysis defaults (the database and schema a USE or
         * an Option sets) stay off it, since a file is no object of a database (SQL Server BULK INSERT, Mantis 4962); the
         * file-path database and schema options still apply.
         */
        public void setPath(boolean isPath, boolean defaultQualifiers) {
                this.isPath = isPath;
                if(isPath && !defaultQualifiers) {
                        String filePathDatabase = ModelBindingManager.getGlobalOption().getFilePathDatabase();
                        String filePathSchema = ModelBindingManager.getGlobalOption().getFilePathSchema();
                        EDbVendor vendor = ModelBindingManager.getGlobalOption().getVendor();
                        boolean supportCatalog = TSQLEnv.supportCatalog(vendor);
                        boolean supportSchema = TSQLEnv.supportSchema(vendor);
                        assignDatabase(supportCatalog && !SQLUtil.isEmpty(filePathDatabase) ? filePathDatabase : null, null);
                        assignSchema(supportSchema && !SQLUtil.isEmpty(filePathSchema) ? filePathSchema : null, null);
                        // the constructor already folded the defaults into the name; start again from the name as written
                        if (this.fullName != null) {
                                this.name = this.fullName;
                        }
                        updateTableName(supportCatalog, supportSchema);
                        return;
                }
                if(isPath) {
                        String filePathDatabase = ModelBindingManager.getGlobalOption().getFilePathDatabase();
                        String filePathSchema = ModelBindingManager.getGlobalOption().getFilePathSchema();
                        if(SQLUtil.isEmpty(filePathDatabase)) {
                                assignDatabase(null, null);
                        }
                        else {
                                assignDatabase(filePathDatabase, null);
                        }
                        if(SQLUtil.isEmpty(filePathSchema)) {
                                assignSchema(null, null);
                        }
                        else {
                                assignSchema(filePathSchema, null);
                        }

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

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

                        updateTableName(supportCatalog, supportSchema);
                }
        }

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

        public String getLocation() {
                return location;
        }

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

        /** The external data source a file path is read through (BULK INSERT ... WITH (DATA_SOURCE = ...)), or null. */
        public String getDataSourceName() {
                return dataSourceName;
        }

        public void setDataSourceName(String dataSourceName) {
                this.dataSourceName = dataSourceName;
        }

        /**
         * The URI of a file path when it differs from its name: the data source's LOCATION joined with the path the
         * statement names; null when the URI is the name.
         */
        public String getPathUri() {
                return pathUri;
        }

        public void setPathUri(String pathUri) {
                this.pathUri = pathUri;
        }

        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) {
                assignDatabase(database, null);
        }

        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 = gudusoft.gsqlparser.dlineage.util.LegacyDlineageWireNamesV1.tableName(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);
                }
        }
}