package gudusoft.gsqlparser.dlineage.util;

import java.io.File;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

import gudusoft.gsqlparser.EDbVendor;
import gudusoft.gsqlparser.EParameterMode;
import gudusoft.gsqlparser.TCustomSqlStatement;
import gudusoft.gsqlparser.dlineage.dataflow.model.AnalyzeMode;
import gudusoft.gsqlparser.dlineage.dataflow.model.Column;
import gudusoft.gsqlparser.dlineage.dataflow.model.ModelBindingManager;
import gudusoft.gsqlparser.dlineage.dataflow.model.Option;
import gudusoft.gsqlparser.dlineage.dataflow.model.SqlInfo;
import gudusoft.gsqlparser.dlineage.dataflow.model.SubType;
import gudusoft.gsqlparser.dlineage.dataflow.model.Table;
import gudusoft.gsqlparser.dlineage.dataflow.model.xml.*;
import gudusoft.gsqlparser.nodes.TFunctionCall;
import gudusoft.gsqlparser.nodes.TObjectName;
import gudusoft.gsqlparser.nodes.TParameterDeclaration;
import gudusoft.gsqlparser.nodes.TParameterDeclarationList;
import gudusoft.gsqlparser.sqlenv.IdentifierService;
import gudusoft.gsqlparser.sqlenv.IdentifierCodec;
import gudusoft.gsqlparser.sqlenv.IdentifierInputForm;
import gudusoft.gsqlparser.sqlenv.IdentifierProfile;
import gudusoft.gsqlparser.sqlenv.QualifiedCanonKey;
import gudusoft.gsqlparser.sqlenv.QualifiedNameHierarchy;
import gudusoft.gsqlparser.sqlenv.ESQLDataObjectType;
import gudusoft.gsqlparser.sqlenv.TSQLEnv;
import gudusoft.gsqlparser.stmt.TCommonBlock;
import gudusoft.gsqlparser.stmt.TSelectSqlStatement;
import gudusoft.gsqlparser.stmt.TCreateFunctionStmt;
import gudusoft.gsqlparser.stmt.TStoredProcedureSqlStatement;
import gudusoft.gsqlparser.stmt.mssql.TMssqlBlock;
import gudusoft.gsqlparser.stmt.mssql.TMssqlCreateFunction;
import gudusoft.gsqlparser.stmt.oracle.TPlsqlCreatePackage;
import gudusoft.gsqlparser.TBaseType;
import gudusoft.gsqlparser.util.SQLUtil;
import gudusoft.gsqlparser.stmt.teradata.TTeradataCreateProcedure;
import gudusoft.gsqlparser.util.SQLUtil;
import gudusoft.gsqlparser.util.functionChecker;
import gudusoft.gsqlparser.util.keywordChecker;
import gudusoft.gsqlparser.util.json.JSON;

public class DlineageUtil {

    /**
     * Whether a serialized coordinate ("[line,col,offset],[line,col,offset]...")
     * points at a real reference site. A position synthesized for a column that
     * has no source token renders as "[1,1,0],[1,n,0]" (start-of-module, width =
     * name length) or carries -1 markers; a genuine column reference can never
     * start at line 1, column 1, because the statement head keyword occupies
     * that position.
     */
    public static boolean hasUsableCoordinate(String coordinate) {
        if (SQLUtil.isEmpty(coordinate)) {
            return false;
        }
        String trimmed = coordinate.trim();
        return !trimmed.startsWith("[1,1,") && !trimmed.startsWith("[-1,-1,");
    }

    public static boolean compareIdentifier(String source, String target, ESQLDataObjectType sqlDataObjectType) {
        return SQLUtil.compareIdentifier(ModelBindingManager.getGlobalVendor(), sqlDataObjectType, source, target);
    }

    public static boolean compareColumnIdentifier(String source, String target) {
        return SQLUtil.compareIdentifier(ModelBindingManager.getGlobalVendor(), ESQLDataObjectType.dotColumn, source,
                target);
    }

    public static boolean compareTableIdentifier(String source, String target) {
        return SQLUtil.compareIdentifier(ModelBindingManager.getGlobalVendor(), ESQLDataObjectType.dotTable, source,
                target);
    }

    /**
     * Whether the analysis runs under identifier rules of its own rather than its vendor's
     * defaults; only then do lineage name comparisons and keys follow the analysis's service.
     */
    public static boolean configuresIdentifierRules() {
        return configuredIdentifierService() != null;
    }

    /**
     * Single-segment identifier equality via the unified façade, using the bound
     * global analysis vendor; falls back to case-insensitive comparison when no
     * vendor is bound (model classes used outside an analysis run).
     */
    public static boolean sameName(ESQLDataObjectType objectType, String a, String b) {
        if (a == null || b == null) {
            return false;
        }
        IdentifierService service = configuredIdentifierService();
        if (service != null) {
            return service.areEqual(a, b, objectType);
        }
        EDbVendor vendor = ModelBindingManager.getGlobalVendor();
        return vendor == null ? a.equalsIgnoreCase(b) : SQLUtil.sameName(vendor, objectType, a, b);
    }

    /**
     * Like {@link #sameName} but for possibly-qualified names; routes through the
     * segmenting {@link SQLUtil#compareIdentifier}.
     */
    public static boolean sameQualifiedName(ESQLDataObjectType objectType, String a, String b) {
        if (a == null || b == null) {
            return false;
        }
        // Reflexivity guard: degenerate model names (e.g. the literal ".") defeat
        // compareIdentifier's segmentation, but identical strings are always the same name.
        if (a.equals(b)) {
            return true;
        }
        IdentifierService service = configuredIdentifierService();
        if (service != null) {
            return SQLUtil.compareIdentifier(service, objectType, withSessionSchema(a), withSessionSchema(b));
        }
        EDbVendor vendor = ModelBindingManager.getGlobalVendor();
        return vendor == null ? a.equalsIgnoreCase(b) // non-identifier-compare: no analysis vendor bound
                : SQLUtil.compareIdentifier(vendor, objectType, withSessionSchema(a), withSessionSchema(b));
    }

    /**
     * The identity key of a table name, or of a table alias, AS WRITTEN IN SQL: a
     * {@link QualifiedCanonKey} under the analysis's identifier rules (its configured profile, else its
     * vendor's defaults), with an omitted SQL Server schema filled in as {@link #withSessionSchema}
     * does. Text that is not a qualified identifier (a database link written into the name, a
     * function-call shape) is keyed exactly, as a label, so it never merges with another spelling.
     *
     * <p>Only for text the SQL spelled. A model's display name has lost its quote state and must not
     * be keyed here.</p>
     */
    public static Object tableNameKey(String lexical) {
        if (lexical == null) {
            return null;
        }
        String name = withSessionSchema(lexical);
        IdentifierService service = ModelBindingManager.getGlobalIdentifierService();
        if (service != null && !name.isEmpty()) {
            try {
                QualifiedCanonKey key = service.qualifiedCanonKeyFromLexical(name, ESQLDataObjectType.dotTable);
                if (key != null) {
                    return key;
                }
            } catch (RuntimeException notAQualifiedName) {
                // keyed exactly below
            }
        }
        return gudusoft.gsqlparser.dlineage.dataflow.model.ModelLabelKey.of(
                gudusoft.gsqlparser.dlineage.dataflow.model.ModelLabelKey.Kind.SYNTHETIC, name);
    }

    /**
     * The identity key of a schema name AS WRITTEN IN SQL ({@code CREATE SCHEMA s CLONE db.src}): a
     * {@link QualifiedCanonKey} of {@code dotSchema} under the analysis's identifier rules, its segments the
     * catalog and the schema. Text the rules cannot read as a name is keyed exactly, as a label, so it never
     * merges with another spelling.
     */
    public static Object schemaNameKey(String lexical) {
        return analysisNameKey(lexical, ESQLDataObjectType.dotSchema);
    }

    /**
     * The identity key of a name AS WRITTEN IN SQL in the role {@code objectType} ({@code dotCatalog} for the
     * database of {@code CREATE DATABASE d CLONE src}): a {@link QualifiedCanonKey} under the analysis's identifier
     * rules. Text the rules cannot read as a name is keyed exactly, as a label, so it never merges with another
     * spelling.
     */
    public static Object analysisNameKey(String lexical, ESQLDataObjectType objectType) {
        if (lexical == null) {
            return null;
        }
        IdentifierService service = ModelBindingManager.getGlobalIdentifierService();
        if (service != null && !lexical.isEmpty()) {
            try {
                QualifiedCanonKey key = service.qualifiedCanonKeyFromLexical(lexical, objectType);
                if (key != null) {
                    return key;
                }
            } catch (RuntimeException notAQualifiedName) {
                // keyed exactly below
            }
        }
        return gudusoft.gsqlparser.dlineage.dataflow.model.ModelLabelKey.of(
                gudusoft.gsqlparser.dlineage.dataflow.model.ModelLabelKey.Kind.SYNTHETIC, lexical);
    }

    /**
     * A SQL Server name may omit its schema ({@code db..t}); the omission means the session's
     * default schema, a fact about the analysis rather than about the name. Every interior empty
     * segment is filled with it: the schema the analysis is in, else {@code dbo}. This is the
     * qualification lineage has always applied before comparing such names. Segments are split by
     * {@link SQLUtil#parseNames}, so a delimited segment such as {@code [a..b]} is never looked into.
     *
     * @return the name with its omitted schema filled in, or the name unchanged for any other vendor
     */
    public static String withSessionSchema(String qualifiedName) {
        return withSessionSchema(ModelBindingManager.getGlobalVendor(), qualifiedName);
    }

    /** {@link #withSessionSchema(String)} for a vendor given explicitly. */
    public static String withSessionSchema(EDbVendor vendor, String qualifiedName) {
        if (qualifiedName == null || (vendor != EDbVendor.dbvmssql && vendor != EDbVendor.dbvazuresql)
                || qualifiedName.indexOf('.') == -1) {
            return qualifiedName;
        }
        List<String> segments = SQLUtil.parseNames(qualifiedName);
        boolean filled = false;
        for (int i = 1; i < segments.size() - 1; i++) {
            if (segments.get(i).isEmpty() && !segments.get(i - 1).isEmpty()) {
                String schema = ModelBindingManager.getGlobalSchema();
                segments.set(i, schema != null ? schema : "dbo");
                filled = true;
            }
        }
        return filled ? String.join(".", segments) : qualifiedName;
    }

    /**
     * Canonical equality of the column (last) segments of two references — the
     * canonical counterpart of comparing {@link #getColumnName(String)} results:
     * same naive last-dot split, same trim and empty-segment fallback, but the raw
     * segments go to the canonical engine instead of normalize-then-equalsIgnoreCase.
     */
    public static boolean sameColumnSegment(String a, String b) {
        return sameName(ESQLDataObjectType.dotColumn, columnSegmentOf(a), columnSegmentOf(b));
    }

    /**
     * Whether two column NORMAL names (results of {@link #getIdentifierNormalColumnName}) name the
     * same column. Lineage has always matched normal names case-insensitively; this keeps that and
     * only narrows it, so two names that differ just in case match only when the identifier rules
     * say they are one name. ClickHouse {@code userId} and {@code userid}, which
     * {@link NormalNameCollisions} gives normal names of their own, stay apart.
     */
    public static boolean sameColumnNormalName(String a, String b) {
        if (a == null || b == null) {
            return false;
        }
        if (a.equals(b)) {
            return true;
        }
        // The case-insensitive match lineage always made, narrowed by the identifier rules.
        return a.equalsIgnoreCase(b) && sameName(ESQLDataObjectType.dotColumn, a, b); // non-identifier-compare: legacy normal names, the rules decide
    }

    /**
     * Whether a model column's name and a reference name DISPLAY alike: their column segments in the form output
     * version 1 publishes ({@link LegacyDlineageWireNamesV1#columnName}), compared as the vendor compares names. This
     * is a comparison of displays, not of identities, for the places that compare names where identity cannot decide:
     * star links grouped by display ({@code -Dgsp.dlineage.starLinks=legacy}), a label involved, a model name that
     * carries no identity. A model name is display text ({@link gudusoft.gsqlparser.dlineage.dataflow.model.Column#getName}),
     * so reading it as a SQL spelling would compare the wrong thing.
     */
    public static boolean sameColumnDisplay(String modelName, TObjectName name) {
        return compareColumnIdentifier(LegacyDlineageWireNamesV1.columnName(columnSegmentOf(modelName)),
                LegacyDlineageWireNamesV1.columnName(name));
    }

    /** {@link #sameColumnDisplay(String, TObjectName)} of two model names, each cut at its last dot. */
    public static boolean sameColumnDisplay(String modelName, String otherName) {
        return compareColumnIdentifier(LegacyDlineageWireNamesV1.columnName(columnSegmentOf(modelName)),
                LegacyDlineageWireNamesV1.columnName(columnSegmentOf(otherName)));
    }

    /** Canonical counterpart of comparing {@link #getColumnName(TObjectName)} results. */
    public static boolean sameColumnName(TObjectName a, TObjectName b) {
        return sameName(ESQLDataObjectType.dotColumn, rawColumnName(a), rawColumnName(b));
    }

    /** Mixed operand shapes: model name string vs AST object name. */
    public static boolean sameColumnName(String a, TObjectName b) {
        return sameName(ESQLDataObjectType.dotColumn, columnSegmentOf(a), rawColumnName(b));
    }

    /** Mixed operand shapes: AST object name vs model name string. */
    public static boolean sameColumnName(TObjectName a, String b) {
        return sameColumnName(b, a);
    }

    /** Both operands model name strings: see {@link #sameColumnSegment}. */
    public static boolean sameColumnName(String a, String b) {
        return sameColumnSegment(a, b);
    }

    /**
     * Whether two column paths name the same column: the same number of segments, each segment the
     * same COLUMN name. A path here is a column and the fields below it (a BigQuery or Redshift
     * STRUCT path such as {@code customer.name}), so no segment is a table or schema qualifier and
     * none follows the rules of one: on BigQuery tables are case-sensitive while columns and fields
     * are not. For a reference that may carry a table qualifier use {@link #sameQualifiedName}.
     */
    public static boolean sameColumnPath(String a, String b) {
        if (a == null || b == null) {
            return false;
        }
        if (a.equals(b)) {
            return true;
        }
        List<String> left = SQLUtil.parseNames(a);
        List<String> right = SQLUtil.parseNames(b);
        if (left.size() != right.size()) {
            return false;
        }
        for (int i = 0; i < left.size(); i++) {
            if (!left.get(i).equals(right.get(i))
                    && !sameName(ESQLDataObjectType.dotColumn, left.get(i), right.get(i))) {
                return false;
            }
        }
        return true;
    }

    /** {@link #sameColumnPath(String, String)} for a vendor given explicitly, under its default rules. */
    public static boolean sameColumnPath(EDbVendor vendor, String a, String b) {
        if (a == null || b == null) {
            return false;
        }
        if (a.equals(b)) {
            return true;
        }
        List<String> left = SQLUtil.parseNames(a);
        List<String> right = SQLUtil.parseNames(b);
        if (left.size() != right.size()) {
            return false;
        }
        for (int i = 0; i < left.size(); i++) {
            if (!left.get(i).equals(right.get(i))
                    && !SQLUtil.sameName(vendor, ESQLDataObjectType.dotColumn, left.get(i), right.get(i))) {
                return false;
            }
        }
        return true;
    }

    /**
     * Whether a column model is the column a reference names. The model's own identity key, minted
     * from the spelling it was created with, decides whenever both sides have one: the model's name is
     * a display string (delimiters decoded where they are cosmetic) and must not be re-read as SQL. A
     * model without one (a STRUCT path, an expression label, a wildcard) is matched by its name as a
     * column path against the reference's column segment, as written.
     */
    public static boolean columnMatches(Column model, TObjectName reference) {
        if (model == null || reference == null) {
            return false;
        }
        if (model.getIdentifierKey() != null) {
            gudusoft.gsqlparser.sqlenv.CanonKey key = columnKey(reference);
            if (key != null) {
                return model.getIdentifierKey().equals(key);
            }
        }
        return sameColumnPath(model.getName(), rawColumnName(reference));
    }

    /** {@link #columnMatches(Column, TObjectName)} for a reference held as text, as written. */
    public static boolean columnMatches(Column model, String reference) {
        if (model == null || reference == null) {
            return false;
        }
        String segment = columnSegmentOf(reference);
        EDbVendor vendor = ModelBindingManager.getGlobalVendor();
        if (model.getIdentifierKey() != null && vendor != null) {
            gudusoft.gsqlparser.sqlenv.CanonKey key;
            try {
                key = lexicalColumnKey(vendor, segment);
            } catch (RuntimeException notAnIdentifier) {
                key = null;
            }
            if (key != null) {
                return model.getIdentifierKey().equals(key);
            }
        }
        return sameColumnPath(model.getName(), segment);
    }

    /**
     * The RAW column (last) segment of a reference — {@link #getColumnName(String)}'s
     * extraction (naive last-dot split, trim, whole-string fallback) WITHOUT the
     * normalization, for callers that canonically compare a segment against a
     * differently-shaped operand.
     */
    public static String columnSegmentOf(String column) {
        if (column == null) {
            return null;
        }
        String name = column.substring(column.lastIndexOf('.') + 1);
        if ("".equals(name.trim())) {
            return column.trim();
        }
        return name.trim();
    }

    /** The column (last) segment of an AST name as written: {@link #getColumnName(TObjectName)} without the normalization. */
    public static String rawColumnName(TObjectName column) {
        if (column == null || column.toString() == null) {
            return null;
        }
        String name = column.getColumnNameOnly();
        if (name == null || "".equals(name.trim())) {
            return column.toString().trim();
        }
        return name.trim();
    }

    /** Identity comes from the AST spelling, never a rendered model name. */
    public static gudusoft.gsqlparser.sqlenv.CanonKey columnKey(TObjectName column) {
        if (column == null || isWildcard(column) || column.getPropertyToken() != null
                || column.getDbObjectType() == gudusoft.gsqlparser.EDbObjectType.variable
                || column.getDbObjectType() == gudusoft.gsqlparser.EDbObjectType.parameter
                || (column.getColumnSource() != null && column.getColumnSource().isStructFieldAccess())) {
            return null;
        }
        EDbVendor vendor = ModelBindingManager.getGlobalVendor();
        return vendor == null ? null : lexicalColumnKey(vendor, rawColumnName(column));
    }

    /**
     * Identity key of a column name as written in SQL: under the analysis's identifier rules
     * when it configures its own, else under the vendor default, as it always was. Every
     * producer of a lineage column key goes through here or {@link #catalogColumnKey}, because a
     * key minted under one profile never equals a key minted under another.
     */
    public static gudusoft.gsqlparser.sqlenv.CanonKey lexicalColumnKey(EDbVendor vendor, String lexical) {
        IdentifierService service = configuredIdentifierService(vendor);
        if (service == null) {
            return SQLUtil.canonKey(vendor, ESQLDataObjectType.dotColumn, lexical);
        }
        return lexical == null ? null
                : service.canonKeyOf(lexical, ESQLDataObjectType.dotColumn, IdentifierInputForm.SQL_LEXICAL);
    }

    /**
     * Identity key of a name as written in SQL, qualified or not, under the same rules as {@link #lexicalColumnKey}
     * (the analysis's rules when it configures its own for this vendor, else the vendor's defaults): a {@link QualifiedCanonKey} of
     * {@code objectType}. Text the rules cannot read as a name is keyed exactly, as a label, so it never merges with
     * another spelling. For readers whose input names are SQL spellings.
     */
    public static Object lexicalNameKey(EDbVendor vendor, String lexical, ESQLDataObjectType objectType) {
        if (lexical == null) {
            return null;
        }
        IdentifierService service = configuredIdentifierService(vendor);
        if (service == null && vendor != null) {
            service = IdentifierService.defaultServiceFor(vendor);
        }
        if (service != null && !lexical.isEmpty()) {
            try {
                QualifiedCanonKey key = service.qualifiedCanonKeyFromLexical(lexical, objectType);
                if (key != null) {
                    return key;
                }
            } catch (RuntimeException notAQualifiedName) {
                // keyed exactly below
            }
        }
        return gudusoft.gsqlparser.dlineage.dataflow.model.ModelLabelKey.of(
                gudusoft.gsqlparser.dlineage.dataflow.model.ModelLabelKey.Kind.SYNTHETIC, lexical);
    }

    /** Identity key of a column name as a catalog stores it; see {@link #lexicalColumnKey}. */
    public static gudusoft.gsqlparser.sqlenv.CanonKey catalogColumnKey(EDbVendor vendor, String storedName) {
        IdentifierService service = configuredIdentifierService(vendor);
        if (service == null) {
            return SQLUtil.canonKey(vendor, ESQLDataObjectType.dotColumn,
                    TSQLEnv.toLexical(vendor, ESQLDataObjectType.dotColumn, storedName, IdentifierInputForm.CATALOG_STORED));
        }
        return storedName == null ? null
                : service.canonKeyOf(storedName, ESQLDataObjectType.dotColumn, IdentifierInputForm.CATALOG_STORED);
    }

    /** A stored column name spelled as SQL, under the same rules as {@link #catalogColumnKey}. */
    public static String catalogColumnLexical(EDbVendor vendor, String storedName) {
        IdentifierService service = configuredIdentifierService(vendor);
        return service == null
                ? TSQLEnv.toLexical(vendor, ESQLDataObjectType.dotColumn, storedName, IdentifierInputForm.CATALOG_STORED)
                : IdentifierCodec.encodeStored(service.getProfile(), ESQLDataObjectType.dotColumn, storedName);
    }

    /**
     * A {@code *} dlineage synthesizes for a whole-table pseudo column (a clone, a rename, a synonym, a COPY target
     * without columns). It has no part token, so the parse's own wildcard test ({@link #isWildcard}) does not take it
     * for a SQL wildcard; {@link #isStarName} knows it by its class.
     */
    public static TObjectName syntheticStarName() {
        return new SyntheticStarName();
    }

    /**
     * Whether a name stands for a star: the parse's wildcard ({@code *}, {@code t.*}), or a star dlineage
     * synthesized ({@link #syntheticStarName}). Decided by the parse and by provenance, never by the text: a
     * delimited column named {@code *}, and a name built from the text {@code *}, are not stars.
     */
    public static boolean isStarName(TObjectName name) {
        return isWildcard(name) || name instanceof SyntheticStarName;
    }

    /**
     * The identity of the last segment of a field path (a struct or property access such as {@code a.left.Name}),
     * the name lineage publishes for such a column. {@link #columnKey} gives a field path no identity of its own;
     * this is the leaf's, under the analysis's rules, for questions about the published leaf name. Null for a name
     * that is not a field path.
     */
    public static gudusoft.gsqlparser.sqlenv.CanonKey fieldLeafKey(TObjectName name) {
        if (name == null || isWildcard(name)) {
            return null;
        }
        if (!isFieldPath(name)) {
            return null;
        }
        String leaf = fieldLeafText(name);
        EDbVendor vendor = ModelBindingManager.getGlobalVendor();
        return vendor == null || leaf == null || leaf.trim().isEmpty() ? null : lexicalColumnKey(vendor, leaf.trim());
    }

    /**
     * Whether lineage models a STRUCT or ROW column as a tree, a declared column with a node for each field path
     * below it (fields, array elements, and the intermediate fields too), and binds a read of a field to that node:
     * BigQuery and the Trino family (Athena, Presto, Trino). The dialects differ only in how a name is read as a
     * column and a field path, which {@link TObjectName#getFieldPathRead()} answers. See
     * gsp_java_core/doc/refactor/bigquery_nested_column_lineage_plan.md.
     *
     * @deprecated read {@code NestedAccessProfile.forVendor(vendor).buildsDeclaredTree()}
     */
    @Deprecated
    public static boolean modelsStructTree(EDbVendor vendor) {
        return gudusoft.gsqlparser.nodes.structured.NestedAccessProfile.forVendor(vendor).buildsDeclaredTree();
    }

    /**
     * {@link #modelsStructTree(EDbVendor)} for the vendor of the analysis.
     *
     * @deprecated read {@code NestedAccessProfile.buildsDeclaredTree()} of the analysis's vendor
     */
    @Deprecated
    public static boolean modelsStructTree() {
        return modelsStructTree(ModelBindingManager.getGlobalVendor());
    }

    /** Whether a name reaches below its column: a property token, or a STRUCT field the resolver found. */
    public static boolean isFieldPath(TObjectName name) {
        return name != null && (name.getPropertyToken() != null
                || (name.getColumnSource() != null && name.getColumnSource().isStructFieldAccess()));
    }

    /**
     * Whether two references name the same field below their column: neither is a field path, or both are and
     * their leaves are the same name. {@link #sameColumnName(TObjectName, TObjectName)} compares the column segment
     * only, so {@code tgt.objcol.a1} and {@code tgt.objcol.a2} are one column there. A lookup for the exact column
     * a write lands in must check this as well, or the second attribute is written into the first (Mantis #4747).
     */
    public static boolean sameFieldLeaf(TObjectName a, TObjectName b) {
        if (a == null || b == null) {
            return false;
        }
        boolean fieldPath = isFieldPath(a);
        if (fieldPath != isFieldPath(b)) {
            return false;
        }
        return !fieldPath || sameName(ESQLDataObjectType.dotColumn, fieldLeafText(a), fieldLeafText(b));
    }

    /**
     * The name of an attribute of a column, {@code column.attribute}, each segment decoded as a column name is:
     * how a {@code TableColumn} for {@code tgt.objcol.attr} is named outside the STRUCT-path vendors, and how an
     * UPDATE or MERGE action names the column it writes into such an attribute. Null when the name has no property
     * token.
     */
    public static String propertyColumnPath(TObjectName name) {
        if (name == null || name.getPartToken() == null || name.getPropertyToken() == null) {
            return null;
        }
        return decodeColumnIdentifier(name.getPartToken().getAstext()) + "."
                + decodeColumnIdentifier(name.getPropertyToken().getAstext());
    }

    /**
     * The last segment of a field path as written: the last of the parts beyond the six the parser names
     * ({@code a.b.c.d.e.f.Name}), else the resolver's field path's last segment, else the property token, else the
     * column segment. The one extractor for a field path's published leaf and for its identity.
     */
    public static String fieldLeafText(TObjectName name) {
        if (name == null) {
            return null;
        }
        java.util.List<gudusoft.gsqlparser.TSourceToken> parts = name.getAdditionalParts();
        if (parts != null && !parts.isEmpty()) {
            return parts.get(parts.size() - 1).getAstext();
        }
        gudusoft.gsqlparser.resolver2.model.ColumnSource source = name.getColumnSource();
        if (source != null && source.isStructFieldAccess() && source.hasFieldPath()
                && source.getFieldPath().getLast() != null) {
            return source.getFieldPath().getLast();
        }
        if (name.getPropertyToken() != null) {
            return propertyLeafToken(name).getAstext();
        }
        return rawColumnName(name);
    }

    /**
     * The last field of a name that has a property token: the property itself, or, when the property is the first
     * of several fields, the last of them. Athena {@code payload.address.city} is read as column {@code payload}
     * with property {@code address}, and ends in the field {@code city} (Mantis 4822); the parse's identifier chain
     * ({@link TObjectName#getIdentifierChain()}) has them all. Null for a name with no property token.
     */
    public static gudusoft.gsqlparser.TSourceToken propertyLeafToken(TObjectName name) {
        if (name == null || name.getPropertyToken() == null) {
            return null;
        }
        java.util.List<gudusoft.gsqlparser.TSourceToken> chain = name.getIdentifierChain();
        for (int i = 0; i < chain.size() - 1; i++) {
            if (chain.get(i) == name.getPropertyToken()) {
                return chain.get(chain.size() - 1);
            }
        }
        return name.getPropertyToken();
    }

    /**
     * Carries a model column's star provenance onto its published column: a column NAMED {@code *} that is not a
     * star is marked {@code star="false"}, so the output, in memory and read back from XML, tells it from a star
     * ({@link gudusoft.gsqlparser.dlineage.dataflow.model.xml.column#standsForStar()}).
     */
    public static void publishStarProvenance(gudusoft.gsqlparser.dlineage.dataflow.model.xml.column element,
            gudusoft.gsqlparser.dlineage.dataflow.model.Column model) {
        if (element != null && model != null && !model.isStarColumn() && "*".equals(element.getName())) {
            element.setStar(Boolean.FALSE);
        }
    }

    /**
     * Whether a relationship endpoint stands for a star: by its published column when the document has one under
     * its id, else by the name the endpoint carries (an endpoint of a column the document does not list, such as a
     * star-link entry, is named after it).
     */
    public static boolean isStarEndpoint(java.util.Map<String, gudusoft.gsqlparser.dlineage.dataflow.model.xml.column> columnsById,
            String id, String name) {
        gudusoft.gsqlparser.dlineage.dataflow.model.xml.column element = columnsById == null || id == null ? null
                : columnsById.get(id);
        return element != null ? element.standsForStar() : "*".equals(name);
    }

    /** The published columns of a document by id, for {@link #isStarEndpoint}. */
    public static java.util.Map<String, gudusoft.gsqlparser.dlineage.dataflow.model.xml.column> outputColumnsById(
            gudusoft.gsqlparser.dlineage.dataflow.model.xml.dataflow document) {
        java.util.Map<String, gudusoft.gsqlparser.dlineage.dataflow.model.xml.column> byId =
                new java.util.HashMap<String, gudusoft.gsqlparser.dlineage.dataflow.model.xml.column>();
        if (document == null) {
            return byId;
        }
        for (gudusoft.gsqlparser.dlineage.dataflow.model.xml.table t
                : gudusoft.gsqlparser.dlineage.dataflow.model.xml.dataflow.getAllTables(document)) {
            if (t.getColumns() == null) {
                continue;
            }
            for (gudusoft.gsqlparser.dlineage.dataflow.model.xml.column c : t.getColumns()) {
                if (c.getId() != null && !byId.containsKey(c.getId())) {
                    byId.put(c.getId(), c);
                }
            }
        }
        return byId;
    }

    public static boolean isWildcard(TObjectName column) {
        return column != null && column.getPartToken() != null
                && column.getPartToken().tokentype == gudusoft.gsqlparser.ETokenType.ttasterisk;
    }

        /**
         * Decode a delimited COLUMN identifier to the name a catalog stores, keeping
         * the author's letter case: {@code [Volgorde]}, {@code "Volgorde"},
         * {@code `Volgorde`} and the SQL Server legacy alias form {@code 'Volgorde'}
         * all become {@code Volgorde}; escapes resolve ({@code [Esc]]aped]} →
         * {@code Esc]aped}). Vendor- and role-aware, so a spelling that is not a
         * delimiter for the analysis vendor is left alone.
         *
         * <p>Used for the column names dlineage PUBLISHES, so that view columns and
         * relationship endpoints carry the same identifier a consumer finds in
         * {@code sys.columns} instead of a syntactic spelling it has to strip
         * itself (GitHub issue #704). Unrecognized or malformed input is returned
         * unchanged.
         *
         * <p><b>Only call this on a string of identifier provenance</b> — a
         * {@code TObjectName} column token or a {@code TAliasClause} alias name.
         * A string CONSTANT reaches the model as quoted text too
         * ({@code 'literal value'} becomes a result-set column name), and decoding
         * one would corrupt the value it carries.
         *
         * <p><b>Nothing is decoded on a vendor whose delimiters carry identity.</b>
         * Quoting is not always cosmetic: where a vendor case-folds UNQUOTED names,
         * the delimiters are what mark a name as case-exact, so Oracle
         * {@code "Purchase Frequency"} and {@code Purchase Frequency} (which folds
         * to {@code PURCHASE FREQUENCY}) are two DIFFERENT columns, and decoding
         * would rename the column rather than clean up its spelling. Such a vendor
         * is skipped ENTIRELY, by {@link #delimitersAreCosmetic}, rather than
         * name-by-name: {@code "DESCRIPTION"} happens to fold to itself and could be
         * decoded safely, but decoding it while {@code "Mixed Case"} keeps its
         * quotes would publish two spelling conventions in one Oracle document and
         * leave consumers no single rule to apply. SQL Server — where {@code [x]},
         * {@code "x"}, {@code 'x'} and {@code x} are all one case-insensitive column
         * — is cosmetic throughout, which is why issue #704 is a SQL Server issue.
         *
         * <p><b>A name whose payload contains a dot keeps its delimiters</b>, even
         * on a vendor that passes the test above. Model names double as keys in the
         * dot-delimited qualified-name domain that {@link SQLUtil#parseNames}
         * segments, where the delimiters are what stop {@code "name.dot"} from
         * reading as {@code name} qualified by {@code dot} (the invariant
         * {@link SQLUtil#quoteDottedName} exists to keep). Publishing the decoded
         * form there cost a real CTAS lineage edge in the Snowflake corpus — a
         * downstream re-split renamed the target column to {@code dot} and dropped
         * its dependency.
         *
         * <p>In both held-back cases the name is returned exactly as written, so a
         * consumer still has to decode it; that is strictly better than dropping an
         * edge or renaming a column to improve a spelling.
         *
         * @see SQLUtil#decodeDelimitedName
         */
        public static String decodeColumnIdentifier(String name) {
                EDbVendor vendor = ModelBindingManager.getGlobalVendor();
                if (name == null || vendor == null) {
                        // No bound analysis vendor (model classes used outside a run): which
                        // spellings delimit is unknowable, so leave the name as written.
                        return name;
                }
                if (!delimitersAreCosmetic(vendor)) {
                        return name;
                }
                String decoded = SQLUtil.decodeDelimitedName(vendor, ESQLDataObjectType.dotColumn, name);
                if (decoded == null || decoded.equals(name) || !publishable(vendor, decoded)) {
                        return name;
                }
                return decoded;
        }

        /**
         * Decode a delimited identifier that sits in ALIAS position.
         *
         * <p>Same policy as {@link #decodeColumnIdentifier}, plus the vendor-blind
         * apostrophe form: several vendors accept a string literal as a column
         * alias ({@code SELECT c AS 'myTime'} is legal MySQL), and in alias position
         * there is no ambiguity with a value literal to protect against — a
         * {@code TAliasClause} has already proved this token names a column. The
         * column-reference codec cannot make that call, because for MySQL an
         * apostrophe delimits a STRING, not an identifier.
         *
         * <p>The apostrophe branch also preserves what
         * {@code SQLUtil.trimSingleQuote} did here before issue #704: without it,
         * routing aliases through the column codec would REGRESS MySQL
         * {@code AS 'myTime'} from {@code myTime} back to {@code 'myTime'}.
         * The {@link #publishable} guards still apply, so this path can only ever
         * publish a name that survives a downstream re-decode.
         */
        public static String decodeAliasIdentifier(String alias) {
                EDbVendor vendor = ModelBindingManager.getGlobalVendor();
                if (alias == null || vendor == null) {
                        return alias;
                }
                String decoded = decodeColumnIdentifier(alias);
                if (!decoded.equals(alias)) {
                        return decoded;
                }
                String unquoted = SQLUtil.trimSingleQuote(alias);
                if (unquoted.equals(alias) || !publishable(vendor, unquoted)) {
                        return alias;
                }
                // publishable() only knows the COLUMN codec, which on MySQL does not
                // treat an apostrophe as a delimiter. An alias like '''foo''' strips to
                // ''foo'', which THIS method would strip again on the next layer — so a
                // chain of SELECT * views would rename the column at every hop. Require
                // the alias decode to be idempotent too.
                if (!SQLUtil.trimSingleQuote(unquoted).equals(unquoted)) {
                        return alias;
                }
                return unquoted;
        }

        /**
         * Is {@code decoded} safe to PUBLISH as a model name, or would emitting it
         * cost a lineage edge? Two ways a decoded payload becomes a liability:
         *
         * <ol>
         * <li><b>It contains a dot.</b> Model names double as keys in the
         * dot-delimited qualified-name domain that {@link SQLUtil#parseNames}
         * segments, so {@code "name.dot"} decoded to {@code name.dot} reads as
         * {@code name} qualified by {@code dot}. That cost a real Snowflake CTAS
         * edge: a downstream re-split renamed the target column to {@code dot}.</li>
         * <li><b>It is ITSELF a delimited spelling.</b> A legal SQL Server column
         * can be written {@code [[foo]]]}, whose stored name is {@code [foo]} —
         * delimiter-shaped. Publishing {@code [foo]} hands the next consumer of the
         * name a string it decodes AGAIN, to {@code foo}, and source and target
         * stop matching. Verified: that spelling loses its {@code fdd} edge
         * outright.</li>
         * </ol>
         *
         * <p>In both cases the caller keeps the ORIGINAL spelling. A consumer then
         * still has to decode the name itself, which is worse than a clean name but
         * far better than a dropped dependency — a missing edge is invisible in the
         * output, so nobody can tell it is missing.
         */
        private static boolean publishable(EDbVendor vendor, String decoded) {
                if (decoded.indexOf('.') != -1) {
                        return false;
                }
                return decoded.equals(SQLUtil.decodeDelimitedName(vendor, ESQLDataObjectType.dotColumn, decoded));
        }

        /**
         * Probe cache for {@link #delimitersAreCosmetic}: one answer per vendor.
         * {@link java.util.EnumMap} rather than a static table so the answer comes
         * from the identifier façade and follows it if the vendor rules change.
         */
        private static final java.util.Map<EDbVendor, Boolean> COSMETIC_DELIMITERS =
                        java.util.Collections.synchronizedMap(new java.util.EnumMap<EDbVendor, Boolean>(EDbVendor.class));

        /**
         * Does quoting a COLUMN name change which column it names, for this vendor?
         *
         * <p>Asked by round-tripping a deliberately MIXED-CASE probe through the
         * vendor's own canonical quoted spelling and then asking
         * {@link IdentifierService#areEqualStatic} whether the quoted and bare forms
         * are the same identifier. Mixed case is the discriminator: it is exactly
         * what a case-folding vendor's delimiters protect. Equal ⇒ the delimiters
         * are decoration and can be dropped from a published name; not equal ⇒ they
         * are part of the identity and must stay.
         *
         * <p>Computed from the façade rather than listed per vendor, so it tracks
         * the identifier rules instead of drifting from them.
         */
        private static boolean delimitersAreCosmetic(EDbVendor vendor) {
                Boolean cached = COSMETIC_DELIMITERS.get(vendor);
                if (cached != null) {
                        return cached.booleanValue();
                }
                boolean cosmetic;
                try {
                        String probe = "GspDelimiterProbe";
                        String quoted = SQLUtil.quoteDottedName(vendor, ESQLDataObjectType.dotColumn, probe);
                        cosmetic = !quoted.equals(probe)
                                        && IdentifierService.areEqualStatic(vendor, ESQLDataObjectType.dotColumn, quoted, probe);
                } catch (RuntimeException e) {
                        // A vendor the façade cannot answer for keeps its spellings as written.
                        cosmetic = false;
                }
                COSMETIC_DELIMITERS.put(vendor, Boolean.valueOf(cosmetic));
                return cosmetic;
        }

        /**
         * Legacy display/normal-name form of a column reference (global analysis vendor).
         * NOT an equality primitive: to test whether two names refer to the same column use
         * {@link #sameName}, {@link #sameColumnSegment} or {@link #sameColumnName} —
         * comparing normal names with {@code equals}/{@code equalsIgnoreCase} is the pre-P0d
         * bug pattern. Model display-name bookkeeping is the one documented exception (see
         * the identifier normalization guide §6).
         * @deprecated dlineage no longer calls it. For identity use the name service ({@link #sameName},
         *             {@link #sameColumnName}, {@link #lexicalNameKey}); for a published name of output version 1,
         *             {@link LegacyDlineageWireNamesV1#columnName(String)}.
         */
        @Deprecated
        public static String getIdentifierNormalColumnName(String name) {
                return LegacyDlineageWireNamesV1.columnName(name);
        }

        /**
         * Legacy display/normal-name form — for equality use {@link #sameName} /
         * {@link #sameColumnSegment} / {@link #sameColumnName}, not string compares on
         * this result.
         * @deprecated dlineage no longer calls it. For identity use the name service ({@link #sameName},
         *             {@link #sameColumnName}, {@link #lexicalNameKey}); for a published name of output version 1,
         *             {@link LegacyDlineageWireNamesV1#columnName(EDbVendor, String)}.
         */
        @Deprecated
        public static String getIdentifierNormalColumnName(String name, EDbVendor dbVendor) {
                return LegacyDlineageWireNamesV1.columnName(dbVendor, name);
        }

    /**
     * Legacy uppercase-collapsed normal form (global analysis vendor) — for equality use
     * {@link #sameName} / {@link #sameColumnSegment}, not string compares on this result.
     * @deprecated dlineage no longer calls it. For identity use the name service ({@link #sameName},
     *             {@link #sameColumnName}, {@link #lexicalNameKey}); for a published name of output version 1,
     *             {@link LegacyDlineageWireNamesV1#columnSegment(String)}.
     */
    @Deprecated
    public static String normalizeColumnName(String name) {
        return LegacyDlineageWireNamesV1.columnSegment(name);
    }

    /**
     * Legacy uppercase-collapsed normal form — for equality use {@link #sameName} /
     * {@link #sameColumnSegment}, not string compares on this result.
     * @deprecated dlineage no longer calls it. For identity use the name service ({@link #sameName},
     *             {@link #sameColumnName}, {@link #lexicalNameKey}); for a published name of output version 1,
     *             {@link LegacyDlineageWireNamesV1#columnSegment(EDbVendor, String)}.
     */
    @Deprecated
    public static String normalizeColumnName(String name, EDbVendor dbVendor) {
        return LegacyDlineageWireNamesV1.columnSegment(dbVendor, name);
    }

    
    /**
     * Legacy display/normal-name form of a table reference (global analysis vendor;
     * dblink and call-shaped names keep their suffix). NOT an equality primitive — for
     * equality use {@link #sameName} / {@link #sameQualifiedName} /
     * {@link #compareTableIdentifier}.
     * @deprecated dlineage no longer calls it. For identity use the name service ({@link #sameName},
     *             {@link #sameColumnName}, {@link #lexicalNameKey}); for a published name of output version 1,
     *             {@link LegacyDlineageWireNamesV1#tableName(String)}.
     */
    @Deprecated
    public static String getIdentifierNormalTableName(String name) {
        return LegacyDlineageWireNamesV1.tableName(name);
    }

    /**
     * Legacy display/normal-name form of a function reference — for equality use
     * {@link #sameName} with {@code dotFunction}, not string compares on this result.
     * @deprecated dlineage no longer calls it. For identity use the name service ({@link #sameName},
     *             {@link #sameColumnName}, {@link #lexicalNameKey}); for a published name of output version 1,
     *             {@link LegacyDlineageWireNamesV1#functionName(String)}.
     */
    @Deprecated
    public static String getIdentifierNormalFunctionName(String name) {
        return LegacyDlineageWireNamesV1.functionName(name);
    }

    /**
     * Legacy display/normal-name form (global analysis vendor) — for equality use
     * {@link #sameName} / {@link #sameQualifiedName}, not string compares on this result.
     * @deprecated dlineage no longer calls it. For identity use the name service ({@link #sameName},
     *             {@link #sameColumnName}, {@link #lexicalNameKey}); for a published name of output version 1,
     *             {@link LegacyDlineageWireNamesV1#name(String, ESQLDataObjectType)}.
     */
    @Deprecated
    public static String getIdentifierNormalName(String name, ESQLDataObjectType sqlDataObjectType) {
        return LegacyDlineageWireNamesV1.name(name, sqlDataObjectType);
    }

    /**
     * NORMALIZED display form of the column (last) segment of an AST object name. For
     * equality prefer {@link #sameColumnName(TObjectName, TObjectName)} — it feeds the
     * RAW segment to the canonical engine instead of comparing normalized display text.
     * @deprecated dlineage no longer calls it. For identity use the name service ({@link #sameName},
     *             {@link #sameColumnName}, {@link #lexicalNameKey}); for a published name of output version 1,
     *             {@link LegacyDlineageWireNamesV1#columnName(TObjectName)}.
     */
    @Deprecated
    public static String getColumnName(TObjectName column) {
        return LegacyDlineageWireNamesV1.columnName(column);
    }
    
    /**
     * NORMALIZED display form of the column (last) segment of a model reference (naive
     * last-dot split). For equality prefer {@link #sameColumnSegment(String, String)} —
     * it feeds the RAW segment to the canonical engine instead of comparing normalized
     * display text.
     * @deprecated dlineage no longer calls it. For identity use the name service ({@link #sameName},
     *             {@link #sameColumnName}, {@link #lexicalNameKey}); for a published name of output version 1,
     *             {@link LegacyDlineageWireNamesV1#columnName(String)} of {@link #columnSegmentOf}.
     */
    @Deprecated
    public static String getColumnName(String column) {
                if (column == null) {
                        return null;
                }
                String name = column.substring(column.lastIndexOf(".") + 1);
                if (name == null || "".equals(name.trim())) {
                        return LegacyDlineageWireNamesV1.columnName(column.toString().trim());
                } else
                        return LegacyDlineageWireNamesV1.columnName(name.trim());
        }

    public static boolean isTempTable(Table tableModel, EDbVendor vendor) {
                if (SubType.temp_table == tableModel.getSubType()) {
                        return true;
                }
        switch (vendor) {
            case dbvmssql:
            case dbvazuresql:
                return tableModel.getName().startsWith("#") && !tableModel.getName().startsWith("##");
            default:
                return false;
        }
    }

    /**
     * dlineage's display name of a table: qualified with the current default database and schema,
     * in the form output version 1 publishes ({@link LegacyDlineageWireNamesV1#tableBucket}). Besides
     * the display, it is only the compatibility bucket of a table that carries no identity. Not an
     * identity, and not a name to look a table up with: see {@link #getTableIdentityKey} and
     * {@link #getTableFullNameAsWritten}.
     */
    public static String getTableFullName(String tableName) {
                if (ModelBindingManager.get() != null && ModelBindingManager.get().isDblinkTable(tableName)) {
                        return tableName;
                }
        if(tableName == null){
            return null;
        }
        return LegacyDlineageWireNamesV1.tableBucket(getTableFullNameAsWritten(tableName));
    }

    /** Internal table binding key. Keep lexical provenance before legacy display folding.
     * BigQuery keys the fully qualified name; every other vendor keeps its legacy qualification
     * (the same default database/schema text {@link #getTableFullNameAsWritten} adds) and keys
     * that with the analysis's identifier rules instead of the vendor-default fold, so two tables
     * a configured profile keeps apart are not merged into one lineage model.
     */
    public static Object getTableIdentityKey(String lexicalName) {
        if (ModelBindingManager.getGlobalVendor() == EDbVendor.dbvbigquery) {
            if (lexicalName == null || lexicalName.isEmpty()) return null;
            // The analysis's own service — the same one the catalog and resolver used. Minting this
            // key from a freshly built vendor-default profile would key the lineage model under
            // rules the rest of the run never applied, so a configured analysis would dedup
            // tables differently from the way it resolved them.
            IdentifierService service = ModelBindingManager.getGlobalIdentifierService();
            if (service == null) {
                service = IdentifierService.defaultServiceFor(EDbVendor.dbvbigquery);
            }
            IdentifierProfile profile = service.getProfile();
            List<String> segments = new ArrayList<String>(
                    QualifiedNameHierarchy.split(EDbVendor.dbvbigquery, lexicalName));
            // Default catalog/schema values are stored names; source segments stay lexical.
            // Use the same active/default context as Table, without going through its display.
            if (segments.size() == 1) {
                String schema = ModelBindingManager.getGlobalSchema();
                if (schema == null) schema = IdentifierCodec.encodeStored(profile, ESQLDataObjectType.dotSchema,
                        ModelBindingManager.getEffectiveDefaultSchema());
                segments.add(0, schema);
            }
            if (segments.size() == 2) {
                String database = ModelBindingManager.getGlobalDatabase();
                if (database == null) database = IdentifierCodec.encodeStored(profile, ESQLDataObjectType.dotCatalog,
                        ModelBindingManager.getEffectiveDefaultDatabase());
                segments.add(0, database);
            }
            return service.qualifiedCanonKeyFromLexical(
                    String.join(".", segments), ESQLDataObjectType.dotTable);
        }
        if (lexicalName == null) {
            return null;
        }
        String legacyKey = getTableFullName(lexicalName);
        IdentifierService service = analysisIdentifierService();
        return service == null ? legacyKey
                : analysisTableKey(service, getTableFullNameAsWritten(lexicalName), legacyKey);
    }

    public static Object getTableIdentityKeyWithDefaultSchema(String lexicalName) {
        if (ModelBindingManager.getGlobalVendor() == EDbVendor.dbvbigquery) {
            return getTableIdentityKey(lexicalName);
        }
        if (lexicalName == null) {
            return null;
        }
        String legacyKey = getTableFullNameWithDefaultSchema(lexicalName);
        IdentifierService service = analysisIdentifierService();
        return service == null ? legacyKey
                : analysisTableKey(service, getTableFullNameWithDefaultSchemaAsWritten(lexicalName), legacyKey);
    }

    /**
     * Merge key of a physical table or view by the qualified name the output carries: the
     * analysis's identity where the name has one, else the legacy folded name. BigQuery tables
     * carry their own identity key and keep the folded name here.
     */
    public static Object getQualifiedTableIdentityKey(String qualifiedName) {
        String legacyKey = LegacyDlineageWireNamesV1.tableBucket(qualifiedName);
        IdentifierService service = ModelBindingManager.getGlobalVendor() == EDbVendor.dbvbigquery
                ? null : configuredIdentifierService();
        return service == null ? legacyKey : analysisTableKey(service, qualifiedName, legacyKey);
    }

    /**
     * The merge key of a physical table or view in an output dataflow: its legacy folded name,
     * unless another table already holds that name with a different identity under the
     * analysis's rules, in which case it gets a key of its own. Keeping the legacy string
     * wherever the rules agree keeps merge order and column keys exactly as they were; only
     * tables the analysis keeps apart stop being merged into one.
     *
     * @param identitiesByLegacyName state shared by every table of one merge
     */
    public static String physicalTableMergeKey(Map<String, List<Object>> identitiesByLegacyName, String legacyKey,
            String qualifiedTableName) {
        if (legacyKey == null || ModelBindingManager.getGlobalVendor() == EDbVendor.dbvbigquery) {
            return legacyKey;
        }
        IdentifierService service = configuredIdentifierService();
        if (service == null) {
            return legacyKey;
        }
        Object identityKey = analysisTableKey(service, qualifiedTableName, legacyKey);
        if (!(identityKey instanceof TableIdentityKey)) {
            return legacyKey;
        }
        List<Object> identities = identitiesByLegacyName.get(legacyKey);
        if (identities == null) {
            identities = new ArrayList<Object>();
            identitiesByLegacyName.put(legacyKey, identities);
        }
        int index = identities.indexOf(identityKey);
        if (index < 0) {
            identities.add(identityKey);
            index = identities.size() - 1;
        }
        return index == 0 ? legacyKey : legacyKey + "\u0001" + index;
    }

    /**
     * The identity a published table name reads as, under the analysis's identifier rules: the name
     * taken as a SQL spelling. Weaker evidence than a carried identity, since a stored name is published
     * bare; {@link PhysicalTableMergeKeys} uses it only where no carried identity decides.
     *
     * @return null when the analysis has no service or the name has no identity (a database link, a
     *         shape the vendor's hierarchy cannot split)
     */
    public static QualifiedCanonKey publishedTableIdentity(String qualifiedTableName, String legacyKey) {
        IdentifierService service = analysisIdentifierService();
        if (service == null || qualifiedTableName == null) {
            return null;
        }
        Object key = analysisTableKey(service, qualifiedTableName, legacyKey);
        return key instanceof TableIdentityKey ? ((TableIdentityKey) key).getCanonKey() : null;
    }

    /**
     * The identifier rules a lineage table key minted from a SQL spelling follows: the analysis's
     * configured profile, else its vendor's defaults. Session defaults and {@code USE} names are SQL
     * spellings too (the catalog reads them that way: {@code setDefaultSchemaName("Mixed")} makes
     * {@code TSQLEnv.searchTable} miss {@code "Mixed".t}), so a name composed from them is one.
     */
    private static IdentifierService analysisIdentifierService() {
        return ModelBindingManager.getGlobalIdentifierService();
    }

    private static final Map<IdentifierService, Boolean> CONFIGURED_RULES =
            java.util.Collections.synchronizedMap(new java.util.WeakHashMap<IdentifierService, Boolean>());

    /**
     * Whether the analysis runs under identifier rules of its own rather than its vendor's
     * defaults. Only then are lineage tables keyed by the analysis's identity: under the vendor
     * defaults they keep the legacy fold every existing output is built on. The two are not the
     * same relation for every vendor (Redshift delimited names, for one), and which of them is
     * right there is a question about the vendor rule, not one this key should answer silently.
     */
    /** The analysis's identifier service when it configures rules of its own, else null. */
    private static IdentifierService configuredIdentifierService() {
        IdentifierService service = ModelBindingManager.getGlobalIdentifierServiceRaw();
        return service != null && configuresIdentifierRules(service) ? service : null;
    }

    /**
     * The analysis's configured service when it applies to names of {@code vendor}: a configured profile is the
     * analysis's vendor's, so a metadata server of another vendor keeps that vendor's own rules. Null otherwise.
     */
    private static IdentifierService configuredIdentifierService(EDbVendor vendor) {
        IdentifierService service = configuredIdentifierService();
        return service != null && vendor != null && service.getProfile().getVendor() != vendor ? null : service;
    }

    private static boolean configuresIdentifierRules(IdentifierService service) {
        Boolean configured = CONFIGURED_RULES.get(service);
        if (configured == null) {
            IdentifierProfile profile = service.getProfile();
            configured = !profile.hasSameEffectivePolicyAs(
                    IdentifierProfile.forVendor(profile.getVendor(), IdentifierProfile.VendorFlags.defaults()));
            CONFIGURED_RULES.put(service, configured);
        }
        return configured;
    }

    /**
     * Keys a table name, qualified as written, under the analysis's identifier service. A name
     * the service has no identity for — a database link, or a shape the vendor's name hierarchy
     * cannot split — keeps its legacy folded key, which is what it was bound under before.
     */
    private static Object analysisTableKey(IdentifierService service, String qualifiedAsWritten, String legacyKey) {
        if (qualifiedAsWritten == null || qualifiedAsWritten.isEmpty()
                || (ModelBindingManager.get() != null && ModelBindingManager.get().isDblinkTable(qualifiedAsWritten))) {
            return legacyKey;
        }
        EDbVendor vendor = service.getProfile().getVendor();
        if (!QualifiedNameHierarchy.hasHierarchyMapping(vendor, ESQLDataObjectType.dotTable)) {
            return legacyKey;
        }
        // Only a path of valid identifiers has an identity. A name the hierarchy cannot plan, or
        // with a segment that is not an identifier at all (a database link written into the name,
        // a function-call shape), keeps the legacy key it was always bound under.
        List<QualifiedNameHierarchy.Segment> plan = QualifiedNameHierarchy.plan(vendor, ESQLDataObjectType.dotTable,
                QualifiedNameHierarchy.split(vendor, qualifiedAsWritten));
        if (plan == null) {
            return legacyKey;
        }
        for (QualifiedNameHierarchy.Segment segment : plan) {
            if (!IdentifierCodec.isVendorValidSpelling(service.getProfile(), segment.getType(), segment.getText())) {
                return legacyKey;
            }
        }
        QualifiedCanonKey canonKey;
        try {
            canonKey = service.qualifiedCanonKeyFromLexical(qualifiedAsWritten, ESQLDataObjectType.dotTable);
        } catch (UnsupportedOperationException e) {
            return legacyKey;
        } catch (IllegalArgumentException e) {
            return legacyKey;
        }
        return canonKey == null ? legacyKey : new TableIdentityKey(canonKey, legacyKey);
    }

    /**
     * The SQL spelling of a stored database or schema name: the bare name when the bare word, read as
     * SQL, is that stored name (PostgreSQL {@code public}), else its delimited spelling (a schema stored
     * as {@code Mixed} is {@code "Mixed"}). A name already delimited is returned as it is.
     */
    public static String storedNameSpelling(ESQLDataObjectType role, String name) {
        if (name == null || name.isEmpty()) {
            return name;
        }
        IdentifierService service = analysisIdentifierService();
        if (service == null) {
            service = IdentifierService.defaultServiceFor(ModelBindingManager.getGlobalVendor());
        }
        IdentifierProfile profile = service.getProfile();
        if (IdentifierCodec.isQuoted(profile, role, name)) {
            return name;
        }
        if (name.indexOf('.') < 0 && IdentifierCodec.isVendorValidSpelling(profile, role, name)
                && service.canonKeyOf(name, role, IdentifierInputForm.SQL_LEXICAL)
                        .equals(service.canonKeyOf(name, role, IdentifierInputForm.CATALOG_STORED))) {
            return name;
        }
        return IdentifierCodec.hasQuotedForm(profile, role) ? IdentifierCodec.encodeStored(profile, role, name) : name;
    }

    /**
     * The same qualification as {@link #getTableFullName}, with the name kept AS WRITTEN. Quote
     * state is part of a name's identity (Oracle {@code "Orders"} is not {@code Orders}, which
     * means {@code ORDERS}), so this is the form to ask the catalog with.
     */
    public static String getTableFullNameAsWritten(String tableName) {
                if (ModelBindingManager.get() != null && ModelBindingManager.get().isDblinkTable(tableName)) {
                        return tableName;
                }

        if(tableName == null){
            return null;
        }

        if (tableName.startsWith("`") && tableName.endsWith("`") && tableName.indexOf(".") != -1
                                && ModelBindingManager.getGlobalOption().getVendor() == EDbVendor.dbvbigquery) {
                        tableName = SQLUtil.trimColumnStringQuote(tableName);
                }
        List<String> segments = SQLUtil.parseNames(tableName);
        if (segments.size() == 1) {
            StringBuffer buffer = new StringBuffer();
            if (ModelBindingManager.getGlobalDatabaseSpelling() != null) {
                buffer.append(ModelBindingManager.getGlobalDatabaseSpelling()).append(".");
            }
            if (ModelBindingManager.getGlobalSchemaSpelling() != null) {
                buffer.append(ModelBindingManager.getGlobalSchemaSpelling()).append(".");
            }
            buffer.append(tableName);
            return (buffer.toString());
        } else if (segments.size() == 2) {
            if (ModelBindingManager.getGlobalDatabaseSpelling() != null) {
                return (ModelBindingManager.getGlobalDatabaseSpelling() + "." + tableName);
            } else {
                return (tableName);
            }
        } else {
            if ((ModelBindingManager.getGlobalVendor() == EDbVendor.dbvmssql
                    || ModelBindingManager.getGlobalVendor() == EDbVendor.dbvazuresql) && tableName.indexOf("..") != -1) {
                if (ModelBindingManager.getGlobalSchemaSpelling() != null) {
                    return (tableName.replace("..", "." + ModelBindingManager.getGlobalSchemaSpelling() + "."));
                } else if (ModelBindingManager.getGlobalVendor() == EDbVendor.dbvmssql
                        || ModelBindingManager.getGlobalVendor() == EDbVendor.dbvazuresql) {
                    return (tableName.replace("..", ".dbo."));
                } else {
                    return (tableName);
                }
            } else {
                return (tableName);
            }
        }
    }


    
    public static String getSimpleTableName(String tableName) {
        if (tableName.startsWith("`") && tableName.endsWith("`") && tableName.indexOf(".") != -1
                                && ModelBindingManager.getGlobalOption().getVendor() == EDbVendor.dbvbigquery) {
                        tableName = SQLUtil.trimColumnStringQuote(tableName);
                }
        List<String> segments = SQLUtil.parseNames(tableName);
        return segments.get(segments.size()-1);
    }
    
    public static String getColumnNameOnly(String columnName) {
        if (columnName.startsWith("`") && columnName.endsWith("`") && columnName.indexOf(".") != -1
                                && ModelBindingManager.getGlobalOption().getVendor() == EDbVendor.dbvbigquery) {
                columnName = SQLUtil.trimColumnStringQuote(columnName);
                }
        List<String> segments = SQLUtil.parseNames(columnName);
        return segments.get(segments.size()-1);
    }

    public static String getTableSchema(String tableName) {
        EDbVendor vendor = ModelBindingManager.getGlobalOption().getVendor();
        boolean supportSchema = TSQLEnv.supportSchema(vendor);

        if (tableName.startsWith("`") && tableName.endsWith("`") && tableName.indexOf(".") != -1
                && ModelBindingManager.getGlobalOption().getVendor() == EDbVendor.dbvbigquery) {
            tableName = SQLUtil.trimColumnStringQuote(tableName);
        }
        List<String> segments = SQLUtil.parseNames(tableName);
        if (segments.size() == 1) {
            if (supportSchema && ModelBindingManager.getGlobalSchema() != null) {
                return ModelBindingManager.getGlobalSchema();
            }
        } else if (segments.size() == 2) {
            if(supportSchema) {
                return segments.get(0);
            }
        } else {
            if (ModelBindingManager.getGlobalVendor() == EDbVendor.dbvmssql && tableName.indexOf("..") != -1) {
                if (ModelBindingManager.getGlobalSchema() != null) {
                    return ModelBindingManager.getGlobalSchema();
                } else if (ModelBindingManager.getGlobalVendor() == EDbVendor.dbvmssql) {
                    return "dbo";
                }
            } else {
                if(supportSchema) {
                    return segments.get(segments.size() - 2);
                }
            }
        }
        return null;
    }

    public static String getTableServer(String tableName) {
        EDbVendor vendor = ModelBindingManager.getGlobalOption().getVendor();
        boolean supportCatalog = TSQLEnv.supportCatalog(vendor);
        boolean supportSchema = TSQLEnv.supportSchema(vendor);

        if (tableName.startsWith("`") && tableName.endsWith("`") && tableName.indexOf(".") != -1
                && ModelBindingManager.getGlobalOption().getVendor() == EDbVendor.dbvbigquery) {
            tableName = SQLUtil.trimColumnStringQuote(tableName);
        }
        List<String> segments = SQLUtil.parseNames(tableName);
        if (segments.size() <= 2) {
            return ModelBindingManager.getGlobalServer();
        } else if (segments.size() == 3) {
            if(supportCatalog && supportSchema) {
                return ModelBindingManager.getGlobalServer();
            } else {
                return segments.get(0);
            }
        } else {
            if(supportCatalog && supportSchema) {
                    return segments.get(segments.size() - 4);
            } else {
                return segments.get(segments.size() - 3);
            }
        }
    }

    public static String getTableDatabase(String tableName) {
        EDbVendor vendor = ModelBindingManager.getGlobalOption().getVendor();
        boolean supportCatalog = TSQLEnv.supportCatalog(vendor);
        boolean supportSchema = TSQLEnv.supportSchema(vendor);

        if (tableName.startsWith("`") && tableName.endsWith("`") && tableName.indexOf(".") != -1
                                && ModelBindingManager.getGlobalOption().getVendor() == EDbVendor.dbvbigquery) {
                        tableName = SQLUtil.trimColumnStringQuote(tableName);
                }
        List<String> segments = SQLUtil.parseNames(tableName);
        if (segments.size() == 1) {
            if (supportCatalog && ModelBindingManager.getGlobalDatabase() != null) {
                return ModelBindingManager.getGlobalDatabase();
            }
        } else if (segments.size() == 2) {
            if(supportCatalog && supportSchema) {
                if (ModelBindingManager.getGlobalDatabase() != null) {
                    return ModelBindingManager.getGlobalDatabase();
                }
            } else {
                if (supportCatalog) {
                    return segments.get(0);
                }
            }
        } else {
            if (ModelBindingManager.getGlobalVendor() == EDbVendor.dbvmssql && tableName.indexOf("..") != -1) {
                String fullName = tableName;
                if (ModelBindingManager.getGlobalSchema() != null) {
                    fullName = LegacyDlineageWireNamesV1.tableName(
                            tableName.replace("..", "." + ModelBindingManager.getGlobalSchema() + "."));
                } else if (ModelBindingManager.getGlobalVendor() == EDbVendor.dbvmssql) {
                    fullName = LegacyDlineageWireNamesV1.tableName(tableName.replace("..", ".dbo."));
                } else {
                    fullName = LegacyDlineageWireNamesV1.tableName(tableName);
                }
                return getTableDatabase(fullName);
            } else {
                if(supportCatalog && supportSchema) {
                    return segments.get(segments.size() - 3);
                }
                else if(supportCatalog){
                    return segments.get(segments.size() - 2);
                }
            }
        }
        return null;
    }

    public static String getTableFullNameWithDefaultSchema(String tableName) {
        return LegacyDlineageWireNamesV1.tableBucket(getTableFullNameWithDefaultSchemaAsWritten(tableName));
    }

    /**
     * {@link #getTableFullNameWithDefaultSchema} before the legacy fold: the default database and
     * schema added as text, the name itself left as written.
     */
    public static String getTableFullNameWithDefaultSchemaAsWritten(String tableName) {
        EDbVendor vendor = ModelBindingManager.getGlobalOption().getVendor();
        boolean supportCatalog = TSQLEnv.supportCatalog(vendor);
        boolean supportSchema = TSQLEnv.supportSchema(vendor);

        if (tableName.startsWith("`") && tableName.endsWith("`") && tableName.indexOf(".") != -1
                                && ModelBindingManager.getGlobalOption().getVendor() == EDbVendor.dbvbigquery) {
                        tableName = SQLUtil.trimColumnStringQuote(tableName);
                }
        List<String> segments = SQLUtil.parseNames(tableName);
        if (segments.size() == 1) {
            StringBuffer buffer = new StringBuffer();
            if (supportCatalog && ModelBindingManager.getGlobalDatabase() != null) {
                buffer.append(ModelBindingManager.getGlobalDatabase()).append(".");
            }
            if (supportSchema && ModelBindingManager.getGlobalSchema() != null) {
                buffer.append(ModelBindingManager.getGlobalSchema()).append(".");
            } else if (ModelBindingManager.getGlobalVendor() == EDbVendor.dbvmssql) {
                buffer.append("dbo").append(".");
            }
            buffer.append(tableName);
            return (buffer.toString());
        } else if (segments.size() == 2) {
            if (supportCatalog && supportSchema && ModelBindingManager.getGlobalDatabase() != null) {
                return (ModelBindingManager.getGlobalDatabase() + "." + tableName);
            } else {
                return (tableName);
            }
        } else {
            if (ModelBindingManager.getGlobalVendor() == EDbVendor.dbvmssql && tableName.indexOf("..") != -1) {
                if (ModelBindingManager.getGlobalSchema() != null) {
                    return (
                            tableName.replace("..", "." + ModelBindingManager.getGlobalSchema() + "."));
                } else if (ModelBindingManager.getGlobalVendor() == EDbVendor.dbvmssql) {
                    return (tableName.replace("..", ".dbo."));
                } else {
                    return (tableName);
                }
            } else {
                return (tableName);
            }
        }
    }

    @SuppressWarnings("rawtypes")
    public static SqlInfo[] convertSQL(File file, String json) {
        List<SqlInfo> sqlInfos = new ArrayList<SqlInfo>();
        try {
            List sqlContents = (List) JSON.parseObject(json);
            for (int j = 0; j < sqlContents.size(); j++) {
                Map sqlContent = (Map) sqlContents.get(j);
                String sql = (String) sqlContent.get("sql");
                String fileName = (String) sqlContent.get("fileName");
                String filePath = (String) sqlContent.get("filePath");
                if (sql != null && sql.trim().startsWith("{")) {
                    Map queryObject = (Map) JSON.parseObject(sql);
                    List querys = (List) queryObject.get("queries");
                    if (querys != null) {
                        for (int i = 0; i < querys.size(); i++) {
                            Map object = (Map) querys.get(i);
                            SqlInfo info = new SqlInfo();
                            info.setSql(JSON.toJSONString(object));
                            info.setFileName(fileName);
                            info.setFilePath(filePath);
                            info.setOriginIndex(i);
                            sqlInfos.add(info);
                        }
                    } else {
                        SqlInfo info = new SqlInfo();
                        info.setSql(JSON.toJSONString(queryObject));
                        info.setFileName(fileName);
                        info.setFilePath(filePath);
                        info.setOriginIndex(0);
                        sqlInfos.add(info);
                    }
                } else if (sql != null) {
                    SqlInfo info = new SqlInfo();
                    info.setSql(sql);
                    info.setFileName(fileName);
                    info.setFilePath(filePath);
                    info.setOriginIndex(0);
                    sqlInfos.add(info);
                }
            }
        } catch (Exception e) {
            try {
                Map queryObject = (Map) JSON.parseObject(json);
                List querys = (List) queryObject.get("queries");
                if (querys != null) {
                    for (int i = 0; i < querys.size(); i++) {
                        Map object = (Map) querys.get(i);
                        SqlInfo info = new SqlInfo();
                        info.setSql(JSON.toJSONString(object));
                        if (file != null) {
                            info.setFileName(file.getName());
                            info.setFilePath(file.getAbsolutePath());
                        }
                        info.setOriginIndex(i);
                        sqlInfos.add(info);
                    }
                } else {
                    SqlInfo info = new SqlInfo();
                    info.setSql(JSON.toJSONString(queryObject));
                    if (file != null) {
                        info.setFileName(file.getName());
                        info.setFilePath(file.getAbsolutePath());
                    }
                    info.setOriginIndex(0);
                    sqlInfos.add(info);
                }
            } catch (Exception e1) {
                SqlInfo info = new SqlInfo();
                info.setSql(json);
                if (file != null) {
                    info.setFileName(file.getName());
                    info.setFilePath(file.getAbsolutePath());
                }
                info.setOriginIndex(0);
                sqlInfos.add(info);
            }
        }
        return sqlInfos.toArray(new SqlInfo[0]);
    }

    
        public static String getQualifiedTableName(table table) {
                boolean supportCatalog = TSQLEnv.supportCatalog(ModelBindingManager.getGlobalVendor());
                boolean supportSchema = TSQLEnv.supportSchema(ModelBindingManager.getGlobalVendor());
                StringBuilder buffer = new StringBuilder();
                if (supportCatalog && supportSchema) {
                        if (!SQLUtil.isEmpty(table.getDatabase())) {
                                if (ModelBindingManager.getGlobalVendor() == EDbVendor.dbvoracle
                                                && SubType.dblink.name().equals(table.getSubType())) {
                                        //dblink doesn't set database
                                } else {
                                        buffer.append(table.getDatabase());
                                }
                        }
                        if (!SQLUtil.isEmpty(table.getSchema())) {
                                if (buffer.length() > 0) {
                                        buffer.append(".");
                                }
                                buffer.append(table.getSchema());
                        } else {
                                if (buffer.length() > 0) {
                                        buffer.append(".");
                                        if (ModelBindingManager.getGlobalVendor() == EDbVendor.dbvmssql) {
                                                buffer.append("dbo");
                                        } else {
                                                buffer.append(TSQLEnv.DEFAULT_SCHEMA_NAME);
                                        }
                                }
                        }
                        if (buffer.length() > 0) {
                                buffer.append(".");
                        }
                        buffer.append(table.getTableNameOnly());
                }
                else if(supportCatalog) {
                        if (!SQLUtil.isEmpty(table.getDatabase())) {
                                buffer.append(table.getDatabase());
                        }
                        if (buffer.length() > 0) {
                                buffer.append(".");
                        }
                        buffer.append(table.getTableNameOnly());
                }
                else if(supportSchema) {
                        if (!SQLUtil.isEmpty(table.getSchema())) {
                                buffer.append(table.getSchema());
                        }
                        if (buffer.length() > 0) {
                                buffer.append(".");
                        }
                        buffer.append(table.getTableNameOnly());
                }
                if (SubType.dblink.name().equals(table.getSubType())) {
                        buffer.append("@").append(table.getDatabase());
                }
                return buffer.toString();
        }

    public static TCustomSqlStatement getTopStmt(TCustomSqlStatement stmt) {
        if (ModelBindingManager.getGlobalOption() != null && ModelBindingManager.getGlobalOption().getAnalyzeMode() == AnalyzeMode.crud) {
            TCustomSqlStatement parent = stmt.getParentStmt();
            if (parent == null || parent instanceof TPlsqlCreatePackage
                    || parent instanceof TStoredProcedureSqlStatement || parent instanceof TCommonBlock || parent instanceof TMssqlBlock)
                return stmt;
            return getTopStmt(parent);
        } else {
            TCustomSqlStatement parent = stmt.getParentStmt();
            if (parent == null || parent instanceof TPlsqlCreatePackage)
                return stmt;
            return getTopStmt(parent);
        }
    }
    
        public static TCustomSqlStatement getTopBasicStmt(TCustomSqlStatement stmt) {
                TCustomSqlStatement parent = stmt.getParentStmt();
                if (parent == null || parent instanceof TPlsqlCreatePackage || parent instanceof TStoredProcedureSqlStatement
                                || parent instanceof TCommonBlock || parent instanceof TMssqlBlock)
                        return stmt;
                return getTopBasicStmt(parent);
        }

    public static boolean isQuote(String column) {
        return (column.startsWith("\"") && column.endsWith("\"")) || (column.startsWith("'") && column.endsWith("'"))
                || (column.startsWith("[") && column.endsWith("]")) || (column.startsWith("`") && column.endsWith("`"));
    }

    public static TObjectName getProcedureOrFunctionName(TStoredProcedureSqlStatement stmt) {
                if (stmt instanceof TCreateFunctionStmt) {
                        return ((TCreateFunctionStmt) stmt).getFunctionName();
                }
                if (stmt instanceof TMssqlCreateFunction) {
                        return ((TMssqlCreateFunction) stmt).getFunctionName();
                }
                return stmt.getStoredProcedureName();
        }

    public static String getProcedureNameWithArgs(TStoredProcedureSqlStatement stmt) {
                StringBuilder buffer = new StringBuilder();
                TObjectName name = getProcedureOrFunctionName(stmt);
                if (name == null) {
                        return null;
                }
                buffer.append(name.toString());
                if (stmt.getParameterDeclarations() != null && DlineageUtil.supportFunctionOverride(ModelBindingManager.getGlobalVendor())) {
                        buffer.append("(");
                        TParameterDeclarationList parameters = stmt.getParameterDeclarations();
                        for (int i = 0; i < parameters.size(); ++i) {
                                TParameterDeclaration parameter = parameters.getParameterDeclarationItem(i);
                                if(parameter.getDataType()!=null) {
                                        buffer.append(parameter.getDataType().getDataTypeName());
                                }
                                if(i<parameters.size()-1) {
                                        buffer.append(",");
                                }
                        }
                        buffer.append(")");
                }
                return buffer.toString();
        }

    public static String getIdentifierProcedureNameWithArgNum(procedure procedure) {
        StringBuilder buffer = new StringBuilder();
        buffer.append(SQLUtil.trimColumnStringQuote(procedure.getName()));
        if (procedure.getArguments() != null && procedure.getArguments().size() > 0 && DlineageUtil.supportFunctionOverride(ModelBindingManager.getGlobalVendor())) {
            buffer.append("(");
            buffer.append(procedure.getArguments().size());
            buffer.append(")");
        }
        return buffer.toString().toUpperCase(java.util.Locale.ROOT);
    }

    public static String getIdentifierOraclePackageNameWithArgNum(oraclePackage pkg) {
        StringBuilder buffer = new StringBuilder();
        buffer.append(SQLUtil.trimColumnStringQuote(pkg.getName()));
        if (pkg.getArguments() != null && pkg.getArguments().size() > 0 && DlineageUtil.supportFunctionOverride(ModelBindingManager.getGlobalVendor())) {
            buffer.append("(");
            buffer.append(pkg.getArguments().size());
            buffer.append(")");
        }
        return buffer.toString().toUpperCase(java.util.Locale.ROOT);
    }

    public static String getIdentifierFunctionName(table function) {
        StringBuilder buffer = new StringBuilder();
        buffer.append(SQLUtil.trimColumnStringQuote(function.getName()));
        return buffer.toString().toUpperCase(java.util.Locale.ROOT);
    }

    public static String getProcedureNameWithArgNum(TStoredProcedureSqlStatement stmt) {
                StringBuilder buffer = new StringBuilder();
                TObjectName name = getProcedureOrFunctionName(stmt);
                if (name == null) {
                        return null;
                }
                buffer.append(name.toString());
                if (stmt.getParameterDeclarations() != null && DlineageUtil.supportFunctionOverride(ModelBindingManager.getGlobalVendor())) {
                        buffer.append("(");
                        buffer.append(stmt.getParameterDeclarations().size());
                        buffer.append(")");
                }
                return buffer.toString();
        }
    
        public static String getProcedureNameWithInputArgNum(TStoredProcedureSqlStatement stmt) {
                StringBuilder buffer = new StringBuilder();
                TObjectName name = getProcedureOrFunctionName(stmt);
                if (name == null) {
                        return null;
                }
                buffer.append(name.toString());
                if (stmt.getParameterDeclarations() != null && DlineageUtil.supportFunctionOverride(ModelBindingManager.getGlobalVendor())) {
                        buffer.append("(");
                        int count = 0;
                        for (int i = 0; i < stmt.getParameterDeclarations().size(); i++) {
                                if (stmt.getParameterDeclarations().getParameterDeclarationItem(i)
                                                .getParameterMode() == EParameterMode.in) {
                                        count++;
                                }
                        }
                        if (count == 0) {
                                count = stmt.getParameterDeclarations().size();
                        }
                        buffer.append(count);
                        buffer.append(")");
                }
                return buffer.toString();
        }

        public static String getFunctionNameWithArgNum(TFunctionCall function) {
                StringBuilder buffer = new StringBuilder();
                buffer.append(function.getFunctionName().toString());
                if (function.getArgs() != null && DlineageUtil.supportFunctionOverride(ModelBindingManager.getGlobalVendor())) {
                        buffer.append("(");
                        buffer.append(function.getArgs().size());
                        buffer.append(")");
                }
                return buffer.toString();
        }

        public static String getTableSchema(Table tableModel) {
                StringBuilder buffer = new StringBuilder();
                if(tableModel.getDatabase()!=null) {
                        buffer.append(tableModel.getDatabase());
                }
                else {
                        buffer.append(TSQLEnv.DEFAULT_DB_NAME);
                }
                buffer.append(".");
                if(tableModel.getSchema()!=null) {
                        buffer.append(tableModel.getSchema());
                }
                else {
                        buffer.append(TSQLEnv.DEFAULT_SCHEMA_NAME);
                }
                return buffer.toString();
        }
        
        public static String getTableSQLEnvKey(Table tableModel) {
                StringBuilder buffer = new StringBuilder();
                if(tableModel.getDatabase()!=null) {
                        buffer.append(tableModel.getDatabase());
                }
                else {
                        buffer.append(TSQLEnv.DEFAULT_DB_NAME);
                }
                buffer.append(".");
                if(tableModel.getSchema()!=null) {
                        buffer.append(tableModel.getSchema());
                }
                else {
                        buffer.append(TSQLEnv.DEFAULT_SCHEMA_NAME);
                }
                buffer.append(".");
                buffer.append(DlineageUtil.getSimpleTableName(tableModel.getName()));
                return buffer.toString();
        }
        
        /**
         * B1 (routine-summary-scc-design §3): overload-discriminating scope key.
         * The legacy scope key deliberately collides same-named overloads
         * (long-shipped LEGACY behavior); appending a stable digest of the
         * canonical signature descriptor yields one distinct key per overload for
         * the identity-first lookups of SHADOW/ENHANCED (slice B3). Run-scoped
         * only — the digest is Java hashCode-based and must never be persisted.
         */
        public static String identityScopeKey(String legacyScopeKey,
                        gudusoft.gsqlparser.dlineage.dynamicsql.RoutineIdentity identity) {
                if (legacyScopeKey == null || identity == null) {
                        return null;
                }
                // Normalize the legacy part FIRST (the same getTableFullName pass the
                // legacy registration key goes through), then append the discriminator
                // outside normalization so '#' is never fed to identifier folding.
                // The discriminator is the INJECTIVE canonical signature — a hash
                // digest collided across valid Oracle overloads and merged their
                // pools (codex-B3-r3 finding 2b).
                // The \u0002 prefix marks the key (and every key derived from it by
                // suffixing ".var") as IDENTITY-SCOPED: lookups must never
                // re-interpret such a key against another active scope
                // (codex-B3-r4 finding 1). No legacy registration key starts with a
                // control character.
                return "\u0002" + legacyScopeKey + "#" + identity.signatureKey();
        }

        public static String getProcedureParentName(TCustomSqlStatement stmt) {
                if (stmt instanceof TStoredProcedureSqlStatement) {
                        if (((TStoredProcedureSqlStatement) stmt).getStoredProcedureName() != null) {
                                return getOraclePackageName() + ((TStoredProcedureSqlStatement) stmt).getStoredProcedureName().toString();
                        }
                }
                stmt = stmt.getParentStmt();
                if (stmt == null)
                        return null;

        if (stmt instanceof TCommonBlock) {
                        if(((TCommonBlock) stmt).getBlockBody().getParentObjectName() instanceof TStoredProcedureSqlStatement) {
                                stmt = (TStoredProcedureSqlStatement)((TCommonBlock) stmt).getBlockBody().getParentObjectName();
                        }
                }
        
                if (stmt instanceof TStoredProcedureSqlStatement) {
                        if (((TStoredProcedureSqlStatement) stmt).getStoredProcedureName() != null) {
                                String procedureName = getOraclePackageName() + ((TStoredProcedureSqlStatement) stmt).getStoredProcedureName().toString();
                return getTableFullName(procedureName);
                        }
                }
                if (stmt instanceof TTeradataCreateProcedure) {
                        if (((TTeradataCreateProcedure) stmt).getProcedureName() != null) {
                                String procedureName =  ((TTeradataCreateProcedure) stmt).getProcedureName().toString();
                return getTableFullName(procedureName);
                        }
                }

                return getProcedureParentName(stmt);
        }

        private static String getOraclePackageName() {
                if (ModelBindingManager.getGlobalOraclePackage() != null) {
                        return ModelBindingManager.getGlobalOraclePackage().getName() + ".";
                }
                return "";
        }

        public static sourceColumn copySourceColumn(sourceColumn oldSourceName) {
                sourceColumn newSourceColumn = new sourceColumn();
                newSourceColumn.setClauseType(oldSourceName.getClauseType());
                newSourceColumn.setColumn(oldSourceName.getColumn());
                newSourceColumn.setColumn_type(oldSourceName.getColumn_type());
                newSourceColumn.setCoordinate(oldSourceName.getCoordinate());
                newSourceColumn.setId(oldSourceName.getId());
                newSourceColumn.setName(oldSourceName.getName());
                newSourceColumn.setParent_alias(oldSourceName.getParent_alias());
                newSourceColumn.setParent_id(oldSourceName.getParent_id());
                newSourceColumn.setParent_name(oldSourceName.getParent_name());
                newSourceColumn.setSource(oldSourceName.getSource());
                newSourceColumn.setSource_id(oldSourceName.getSource_id());
                newSourceColumn.setSource_name(oldSourceName.getSource_name());
                newSourceColumn.setStruct(oldSourceName.isStruct());
                newSourceColumn.setType(oldSourceName.getType());
                newSourceColumn.setValue(oldSourceName.getValue());
                if(oldSourceName.getTransforms()!=null) {
                        newSourceColumn.setTransforms(new LinkedHashSet<transform>());
                        for(transform transform: oldSourceName.getTransforms()) {
                                newSourceColumn.getTransforms().add(transform);
                        }
                }
                if(oldSourceName.getCandidateParents()!=null) {
                        newSourceColumn.setCandidateParents(new LinkedHashSet<candidateTable>());
                        for(candidateTable candidateTable: oldSourceName.getCandidateParents()) {
                                newSourceColumn.getCandidateParents().add(candidateTable);
                        }
                }
                return newSourceColumn;
        }

        public static boolean supportFunctionOverride(EDbVendor vendor) {
                switch (vendor) {
                case dbvpostgresql:
                case dbvoracle:
                case dbvdb2:
                case dbvmysql:
                case dbvsnowflake:
                case dbvhana:
                case dbvgreenplum:
                case dbvgaussdb:
                case dbvedb:
                case dbvdameng:
                        return true;
                default:
                        return false;
                }
        }
        
        private static final List<String> TERADATA_BUILTIN_FUNCTIONS = Arrays
                        .asList(new String[] { "ACCOUNT", "CURRENT_DATE", "CURRENT_ROLE", "CURRENT_TIME", "CURRENT_TIMESTAMP",
                                        "CURRENT_USER", "DATABASE", "DATE", "PROFILE", "ROLE", "SESSION", "TIME", "USER", "SYSDATE", });
        
        public static boolean isBuiltInFunctionName(String functionName) {
                if (functionName == null)
                        return false;
                try {
                        EDbVendor vendor = ModelBindingManager.getGlobalOption().getVendor();
                        if (vendor == EDbVendor.dbvteradata) {
                                boolean result = TERADATA_BUILTIN_FUNCTIONS.contains(functionName.toUpperCase(java.util.Locale.ROOT));
                                if (result) {
                                        return true;
                                }
                        }

                        List<String> versions = functionChecker.getAvailableDbVersions(vendor);
                        if (versions != null && versions.size() > 0) {
                                for (int i = 0; i < versions.size(); i++) {
                                        // no caller-side folding: isBuiltInFunction folds with
                                        // Locale.ROOT itself; a default-locale toUpperCase here
                                        // breaks the lookup on Turkish JVMs
                                        boolean result = functionChecker.isBuiltInFunction(functionName,
                                                        vendor, versions.get(i));
                                        if (result) {
                                                return result;
                                        }
                                }

                                // boolean result =
                                // TERADATA_BUILTIN_FUNCTIONS.contains(object.toString());
                                // if (result) {
                                // return true;
                                // }
                        }
                } catch (Exception e) {
                }

                return false;
        }
        
        public static boolean isKeyword(String objectName) {
                if (objectName == null)
                        return false;
                try {
                        EDbVendor vendor = ModelBindingManager.getGlobalOption().getVendor();

                        List<String> versions = keywordChecker.getAvailableDbVersions(vendor);
                        if (versions != null && versions.size() > 0) {
                                for (int i = 0; i < versions.size(); i++) {
                                        List<String> segments = SQLUtil.parseNames(objectName);
                                        boolean result = keywordChecker.isKeyword(segments.get(segments.size() - 1),
                                                        vendor, versions.get(i), false);
                                        if (result) {
                                                return result;
                                        }
                                }
                        }
                } catch (Exception e) {
                }

                return false;
        }

        public static TSelectSqlStatement getLeftStmt(TSelectSqlStatement stmt) {
                TSelectSqlStatement current = stmt.getLeftStmt();
                if (current == null) return null;
                while (current.getLeftStmt() != null) {
                        current = current.getLeftStmt();
                }
                return current;
        }

        public static String stripQuotesFromQualifiedName(String qualifiedName) {
                if (SQLUtil.isEmpty(qualifiedName)) {
                        return qualifiedName;
                }

                List<String> segments = SQLUtil.parseNames(qualifiedName);
                StringBuilder sb = new StringBuilder();
                for (int i = 0; i < segments.size(); i++) {
                        if (i > 0) {
                                sb.append('.');
                        }
                        String seg = segments.get(i);
                        sb.append(TBaseType.getTextWithoutQuoted(seg));
                }
                return sb.toString();
        }

        public static boolean isProcedureExcluded(String fullName) {
                if (SQLUtil.isEmpty(fullName)) {
                        return false;
                }

                Option option = ModelBindingManager.getGlobalOption();
                if (option == null) {
                        return false;
                }

                Set<String> excludedNames = option.getExcludedProcedureNames();
                Set<String> excludedPatterns = option.getExcludedProcedurePatterns();

                if ((excludedNames == null || excludedNames.isEmpty()) &&
                        (excludedPatterns == null || excludedPatterns.isEmpty())) {
                        return false;
                }

        if (excludedNames != null) {
            for (String excludedName : excludedNames) {
                if (DlineageUtil.compareIdentifier(fullName, excludedName, ESQLDataObjectType.dotFunction)) {
                    return true;
                }
            }
        }

        if (excludedPatterns != null && !excludedPatterns.isEmpty()) {
            // Generate the qualified-name and all of its trailing segment-suffixes so a
            // schema-qualified pattern can match a more-qualified name. e.g. the pattern
            // "SCHEM.*" matches the Snowflake procedure "DB.SCHEM.PROC" through the suffix
            // "SCHEM.PROC", and "PUBLIC.*" matches "COVID19.PUBLIC.INSERT_CDC_DATA".
            // Segments are parsed with quote-awareness so dots inside a quoted identifier
            // (e.g. "SCHEMA"."PROC.WITH.DOTS") are not split.
            List<String> candidates = buildQualifiedNameSuffixes(fullName);
            for (String pattern : excludedPatterns) {
                if (SQLUtil.isEmpty(pattern)) {
                        continue;
                }
                String normalizedPattern = stripQuotesFromQualifiedName(pattern);
                for (String candidate : candidates) {
                    if (globMatches(normalizedPattern, candidate)) {
                        return true;
                    }
                }
            }
        }

                return false;
        }

        /**
         * Whether {@code text} as a whole matches the exclusion pattern {@code glob}: {@code *} stands for any run of
         * characters and {@code ?} for one character, neither of them a line terminator, and every other character for
         * itself, an ASCII letter in either case. That is the result of the regex {@code (?i)^...$} the pattern used to be
         * turned into, compiled again for every name, computed here in one pass over the pattern: with several {@code *}
         * that regex could retry every way of splitting a long name between them.
         */
        static boolean globMatches(String glob, String text) {
                int[] pattern = glob.codePoints().toArray();
                int[] name = text.codePoints().toArray();
                // matched[j]: the pattern read so far matches the first j code points of the name
                boolean[] matched = new boolean[name.length + 1];
                boolean[] next = new boolean[name.length + 1];
                matched[0] = true;
                for (int c : pattern) {
                        next[0] = c == '*' && matched[0];
                        for (int j = 1; j <= name.length; j++) {
                                int x = name[j - 1];
                                if (c == '*') {
                                        next[j] = matched[j] || (next[j - 1] && !isLineTerminator(x));
                                } else if (c == '?') {
                                        next[j] = matched[j - 1] && !isLineTerminator(x);
                                } else {
                                        next[j] = matched[j - 1] && sameIgnoringAsciiCase(c, x);
                                }
                        }
                        boolean[] swap = matched;
                        matched = next;
                        next = swap;
                }
                return matched[name.length];
        }

        /** The characters a regex {@code .} does not match without {@code DOTALL}. */
        private static boolean isLineTerminator(int c) {
                return c == '\n' || c == '\r' || c == 0x85 || c == 0x2028 || c == 0x2029;
        }

        /** {@code (?i)} without {@code UNICODE_CASE}: only an ASCII letter matches its other case. */
        private static boolean sameIgnoringAsciiCase(int patternChar, int c) {
                if (patternChar == c) {
                        return true;
                }
                if (patternChar >= 'a' && patternChar <= 'z') {
                        return c == patternChar - 32;
                }
                if (patternChar >= 'A' && patternChar <= 'Z') {
                        return c == patternChar + 32;
                }
                return false;
        }

        /**
         * Builds the quote-stripped qualified name and each of its trailing segment-suffixes,
         * longest first. For {@code "DB"."SCHEM"."PROC"} this yields
         * {@code [DB.SCHEM.PROC, SCHEM.PROC, PROC]}. Used by procedure-exclusion pattern
         * matching so a schema-level pattern matches a database-qualified name.
         */
        private static List<String> buildQualifiedNameSuffixes(String fullName) {
                List<String> suffixes = new ArrayList<String>();
                List<String> segments = SQLUtil.parseNames(fullName);
                if (segments == null || segments.isEmpty()) {
                        suffixes.add(stripQuotesFromQualifiedName(fullName));
                        return suffixes;
                }
                List<String> stripped = new ArrayList<String>(segments.size());
                for (String seg : segments) {
                        stripped.add(TBaseType.getTextWithoutQuoted(seg));
                }
                for (int i = 0; i < stripped.size(); i++) {
                        StringBuilder sb = new StringBuilder();
                        for (int j = i; j < stripped.size(); j++) {
                                if (j > i) {
                                        sb.append('.');
                                }
                                sb.append(stripped.get(j));
                        }
                        suffixes.add(sb.toString());
                }
                return suffixes;
        }
}