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

    /**
     * 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;
        }
        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;
        }
        EDbVendor vendor = ModelBindingManager.getGlobalVendor();
        return vendor == null ? a.equalsIgnoreCase(b) : SQLUtil.compareIdentifier(vendor, objectType, a, b);
    }

    /**
     * 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));
    }

    /** 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));
    }

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

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

        /**
         * 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).
         */
        public static String getIdentifierNormalColumnName(String name) {
                EDbVendor dbVendor = ModelBindingManager.getGlobalVendor();
                return SQLUtil.getIdentifierNormalName(dbVendor, name, ESQLDataObjectType.dotColumn);
        }

        /**
         * Legacy display/normal-name form — for equality use {@link #sameName} /
         * {@link #sameColumnSegment} / {@link #sameColumnName}, not string compares on
         * this result.
         */
        public static String getIdentifierNormalColumnName(String name, EDbVendor dbVendor) {
                return SQLUtil.getIdentifierNormalName(dbVendor, name, ESQLDataObjectType.dotColumn);
        }

    /**
     * Legacy uppercase-collapsed normal form (global analysis vendor) — for equality use
     * {@link #sameName} / {@link #sameColumnSegment}, not string compares on this result.
     */
    public static String normalizeColumnName(String name) {
        return SQLUtil.normalizeIdentifier(ModelBindingManager.getGlobalVendor(),  ESQLDataObjectType.dotColumn, name);
    }

    /**
     * Legacy uppercase-collapsed normal form — for equality use {@link #sameName} /
     * {@link #sameColumnSegment}, not string compares on this result.
     */
    public static String normalizeColumnName(String name, EDbVendor dbVendor) {
        return SQLUtil.normalizeIdentifier(dbVendor,  ESQLDataObjectType.dotColumn, 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}.
     */
    public static String getIdentifierNormalTableName(String name) {
                if (name == null) {
                        return null;
                }
                if (ModelBindingManager.get() != null && ModelBindingManager.get().isDblinkTable(name)) {
                        int index = name.lastIndexOf("@");
                        if (index > 0) {
                                return SQLUtil.getIdentifierNormalName(ModelBindingManager.getGlobalVendor(), name.substring(0, index),
                                                ESQLDataObjectType.dotTable) + name.substring(index);
                        } else {
                                return name;
                        }
                }
                if (name.endsWith(")") && name.indexOf("(") != -1) {
                        return SQLUtil.getIdentifierNormalName(ModelBindingManager.getGlobalVendor(),
                                        name.substring(0, name.lastIndexOf("(")), ESQLDataObjectType.dotTable)
                                        + name.substring(name.lastIndexOf("("));
                }
        return SQLUtil.getIdentifierNormalName(ModelBindingManager.getGlobalVendor(), name,
                ESQLDataObjectType.dotTable);
    }

    /**
     * Legacy display/normal-name form of a function reference — for equality use
     * {@link #sameName} with {@code dotFunction}, not string compares on this result.
     */
    public static String getIdentifierNormalFunctionName(String name) {
        return SQLUtil.getIdentifierNormalName(ModelBindingManager.getGlobalVendor(), name,
                ESQLDataObjectType.dotFunction);
    }

    /**
     * Legacy display/normal-name form (global analysis vendor) — for equality use
     * {@link #sameName} / {@link #sameQualifiedName}, not string compares on this result.
     */
    public static String getIdentifierNormalName(String name, ESQLDataObjectType sqlDataObjectType) {
        return SQLUtil.getIdentifierNormalName(ModelBindingManager.getGlobalVendor(), 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.
     */
    public static String getColumnName(TObjectName column) {
        if (column == null || column.toString() == null) {
            return null;
        }
        String name = column.getColumnNameOnly();
        if (name == null || "".equals(name.trim())) {
            return getIdentifierNormalColumnName(column.toString().trim());
        } else
            return getIdentifierNormalColumnName(name.trim());
    }
    
    /**
     * 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.
     */
    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 DlineageUtil.getIdentifierNormalColumnName(column.toString().trim());
                } else
                        return DlineageUtil.getIdentifierNormalColumnName(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;
        }
    }

    public static String getTableFullName(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.getGlobalDatabase() != null) {
                buffer.append(ModelBindingManager.getGlobalDatabase()).append(".");
            }
            if (ModelBindingManager.getGlobalSchema() != null) {
                buffer.append(ModelBindingManager.getGlobalSchema()).append(".");
            }
            buffer.append(tableName);
            return getIdentifierNormalTableName(buffer.toString());
        } else if (segments.size() == 2) {
            if (ModelBindingManager.getGlobalDatabase() != null) {
                return getIdentifierNormalTableName(ModelBindingManager.getGlobalDatabase() + "." + tableName);
            } else {
                return getIdentifierNormalTableName(tableName);
            }
        } else {
            if ((ModelBindingManager.getGlobalVendor() == EDbVendor.dbvmssql
                    || ModelBindingManager.getGlobalVendor() == EDbVendor.dbvazuresql) && tableName.indexOf("..") != -1) {
                if (ModelBindingManager.getGlobalSchema() != null) {
                    return getIdentifierNormalTableName(
                            tableName.replace("..", "." + ModelBindingManager.getGlobalSchema() + "."));
                } else if (ModelBindingManager.getGlobalVendor() == EDbVendor.dbvmssql
                        || ModelBindingManager.getGlobalVendor() == EDbVendor.dbvazuresql) {
                    return getIdentifierNormalTableName(tableName.replace("..", ".dbo."));
                } else {
                    return getIdentifierNormalTableName(tableName);
                }
            } else {
                return getIdentifierNormalTableName(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 = getIdentifierNormalTableName(
                            tableName.replace("..", "." + ModelBindingManager.getGlobalSchema() + "."));
                } else if (ModelBindingManager.getGlobalVendor() == EDbVendor.dbvmssql) {
                    fullName = getIdentifierNormalTableName(tableName.replace("..", ".dbo."));
                } else {
                    fullName = getIdentifierNormalTableName(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) {
        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 getIdentifierNormalTableName(buffer.toString());
        } else if (segments.size() == 2) {
            if (supportCatalog && supportSchema && ModelBindingManager.getGlobalDatabase() != null) {
                return getIdentifierNormalTableName(ModelBindingManager.getGlobalDatabase() + "." + tableName);
            } else {
                return getIdentifierNormalTableName(tableName);
            }
        } else {
            if (ModelBindingManager.getGlobalVendor() == EDbVendor.dbvmssql && tableName.indexOf("..") != -1) {
                if (ModelBindingManager.getGlobalSchema() != null) {
                    return getIdentifierNormalTableName(
                            tableName.replace("..", "." + ModelBindingManager.getGlobalSchema() + "."));
                } else if (ModelBindingManager.getGlobalVendor() == EDbVendor.dbvmssql) {
                    return getIdentifierNormalTableName(tableName.replace("..", ".dbo."));
                } else {
                    return getIdentifierNormalTableName(tableName);
                }
            } else {
                return getIdentifierNormalTableName(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();
    }

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

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

    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" + getTableFullName(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());
                                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);
                StringBuilder regexBuilder = new StringBuilder();
                for (char c : normalizedPattern.toCharArray()) {
                    switch (c) {
                        case '.':
                            regexBuilder.append("\\.");
                            break;
                        case '*':
                            regexBuilder.append(".*");
                            break;
                        case '?':
                            regexBuilder.append(".");
                            break;
                        case '(': case ')': case '[': case ']': case '{': case '}':
                        case '|': case '^': case '$': case '+': case '\\':
                            regexBuilder.append("\\").append(c);
                            break;
                        default:
                            regexBuilder.append(c);
                    }
                }
                String regex = "(?i)^" + regexBuilder.toString() + "$";
                for (String candidate : candidates) {
                    if (candidate.matches(regex)) {
                        return true;
                    }
                }
            }
        }

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